Заметки

🧭 Guide: Building 4 synced SVG shapes that morph into one smiley (no JS)

Joker — Sun, 12 Oct 2025 22:03:15 +0000

What we’re building

A thin equilateral triangle outline in the background that rotates.
Three shapes placed at the triangle’s vertices: a regular 5-point star, a regular (equilateral) triangle, and a square.
All three shapes morph into the same perfect circle (a smiley face via a mask) and back, in sync with the rotation and mask timing.
All shape contours live in HTML (inside and ), no JS, CSS only for styling and timing of visibility/spin.

Why it works (big ideas)

Unified topology for morphing

Browsers morph SVG paths by interpolating numbers in the d attribute. For a clean morph, each path must have the same “shape grammar”: same number/order of commands and numbers.

We enforce this by describing every state (star, triangle, square, circle) as a single path: M + 12 cubic C segments + Z.

Straight lines (square/triangle edges, star arms) are simply degenerate cubics (control points on the line), so they still fit the same “12 × C” pattern.
A perfect-looking circle

The target “one shape” is a circle centered at (50,50) with radius 30. We render it with 12 cubic Bézier arcs (30° each) so it’s smooth (no polygon facets).
Mask for the smiley face

Eyes and mouth are cut out with a . We don’t morph them — we fade the holes on only during the circle phase (so they move in sync with the morph).
Global sync
- All SMIL morphs () use the exact same duration and keyTimes.
- The CSS animations (mask visibility and orbit spin) use the same total duration and linear timing.
- Result: everything switches phases at the same instants.
Safe layout
- The “stage” is 80vmin so it always fills 80% of the smaller viewport side.
- The revolving centers sit on a radius that keeps shapes inside the viewBox while rotating.

Step-by-step (kid-friendly)

Make a stage

Create an SVG that fills a square area (viewBox=»0 0 100 100″) and put it in a centered container sized 80vmin. That keeps things proportional on any screen.
Add a rotating triangle frame

Draw a thin equilateral triangle outline around the center. Put the triangle and your shapes in a and rotate that group with CSS. Now the triangle and shapes spin together.
Place the 3 shapes at the triangle’s corners

We use three s: star, triangle, square. Their centers are exactly at the frame’s three vertices. Sizes are chosen to look balanced and never clip.
Describe each shape with the same “grammar”

Each starts with M, then 12 cubic C segments, then Z.

Even straight edges are drawn with cubic segments whose control points are on the line (so it stays straight). That keeps morphing stable and pretty.
Define the target circle

The circle (smiley body) is drawn as 12 cubic arcs (30° per arc). That gives a visually perfect circle.
Morph the shapes into the circle and back

On each path, add with:
- dur=»11.2s» total;
- hold 5s on the start shape → morph 0.6s → hold 5s on circle → morph 0.6s back;
- implemented with keyTimes=»0;0.4464286;0.5;0.9464286;1″ (those are 5/11.2, 0.6/11.2, etc.).
  
  All three use identical timings.
Cut eyes and mouth only during circle phase

Create a with two circles (eyes) and a curved path (mouth).

Use a CSS animation on the mask group’s opacity with the same 11.2s duration and the same phase splits so the holes show only in the circle phase.
Style once with CSS

Use currentColor to fill all shapes using a single —orange variable. Keep comments clear. Respect prefers-reduced-motion.
Test sync
- On load, everything starts at t=0.
- After ~5s, there’s a 0.6s morph into the circle, the holes appear, the orbit keeps rotating smoothly.
- After another 5s, there’s a 0.6s morph back.
- All events cross the same timestamps → no phase drift.

Troubleshooting checklist

One shape lags behind? Double-check all durations are 11.2s and keyTimes are identical across all and CSS @keyframes.
Edges look polygonal? Make sure the circle is the cubic-Bézier version (not polygon points).
Anything clips the edges? Keep the orbit centers radius and shape sizes as provided.
Motion sensitivity? The code respects prefers-reduced-motion: reduce to disable CSS animations.

Production code for CodePen

Paste the next block into HTML and the second one into CSS.

Only comments, </span>, and <span class="s3"><desc></span> are translated to English. Paths, numbers, timings remain the same.</p></blockquote> <h3><b> HTML</b></h3> <p><a href="https://codepen.io/kodzero/pen/MYKvvVQ">Exapmle of Morph</a></p> <blockquote> <code class="code"><main class="stage"><main class="stage"> <svg viewBox="0 0 100 100" role="img" aria-labelledby="t d" focusable="false"> <title id="t">4 synced shapes → one smiley circle (morphing) Background: a thin equilateral triangle outline rotates. At its vertices sit: a star, an equilateral triangle, and a square. All three morph in sync into a single circle with a smiley (mask), then back. All contours are defined in HTML. No JS.

CSS

html, body {
height: 100%;
margin: 0;
background: #111;
color: #ddd;
font-family: system-ui, -apple-system, Segoe UI, Roboto, sans-serif;
display: grid;
place-items: center;
}

/* Stage = 80% of the smaller viewport side as requested */
.stage {
width: 80vmin;
height: 80vmin;
display: grid;
place-items: center;
}

/* Single color from CSS; paths fill with currentColor */
.stage svg { color: var(—orange); }
.shape { fill: currentColor; }

/* Spin the entire orbit (outline + shapes) in perfect sync */
#orbit {
transform-origin: 50% 50%;
animation: spin 11.2s linear infinite;
}
@keyframes spin {
from { transform: rotate(0deg); }
to { transform: rotate(360deg); }
}

/* Smiley holes visible only during the circle phase — same phase split as morph */
@keyframes holesOnOff {
/* 0–44.64286%: hold original shapes — no holes */
0%, 44.64286% { opacity: 0; }
/* 50–94.64286%: hold the circle — show eyes/mouth */
50%, 94.64286% { opacity: 1; }
/* 94.64286–100%: morph back — hide again */
100% { opacity: 0; }
}
#smileHoles { animation: holesOnOff 11.2s linear infinite both; }

/* Respect reduced motion */
@media (prefers-reduced-motion: reduce) {
#orbit, #smileHoles { animation: none; }
}

☎️ Voice AI Assistant (phone) on AWS + Node.js + Nginx for Laravel / Symfony / WordPress / Drupal — easy to ship, harder to secure (security, real-time)

Joker — Sat, 11 Oct 2025 19:48:11 +0000

A phone-based Voice AI Assistant built with Twilio/Asterisk + Node.js behind Nginx and running alongside your PHP apps (Laravel/Symfony/WordPress/Drupal) spins up fast. For SMB and mid-market, the security profile is risky: prompts/flows, call recordings and transcripts, and operational chains often live with third parties. That increases insider/leak exposure and creates vendor lock-in. Below is a safer direction and why PostgreSQL is outpacing MySQL in this context.

Architecture in 30 seconds
AWS (EC2/ALB) → Nginx (reverse-proxy) → Node.js (telephony + AI routing) + PHP backends (Laravel/Symfony/WordPress/Drupal). LLMs commonly via OpenAI / Azure OpenAI / Claude / AWS Bedrock. Primary DB: PostgreSQL (ideally PostGIS + pgvector); MySQL is fine for classic CRUD, but lags for geo/time windows and retrieval workloads.

Where the security risks show up
• Prompts and orchestration chains (your know-how) and verbose logging often end up outside your perimeter → higher risk of insider misuse and scenario cloning.
• Calls and PII flow through external STT/TTS/LLM providers; retention and deletion controls aren’t truly yours.
• Vendor lock-in: changing LLM/telephony later can break chains, adapters, and tooling.

AI is rewriting the playbook
The last 30 years of web favored content/blogging/e-commerce. With AI, geolocation + schedules for people/companies/resources take the front seat, and real-time orchestration becomes the default. That shift rewards PostgreSQL: PostGIS for coordinates/routes and pgvector for RAG/semantic retrieval. Even in PHP backends, this improves routing of calls/dispatch, time-window logic, and decision speed.

Why SMB and mid-market lean on on-prem
Many teams still trust local racks/Windows-style setups because the data path is short and auditable. When prompts/data stream to outside LLMs (OpenAI, Gemini, Grok, etc.), orgs inevitably consider a self-hosted / open-source route under Apache-2.0 and similar licenses—keeping prompts, vector indexes, and logs inside the perimeter. Configs and secrets live on the company’s own servers with clear RBAC and audit.

A safer path (sketch)
• Self-hosted LLM behind the firewall; RAG on PostgreSQL + pgvector.
• On-prem telephony: Asterisk/FreeSWITCH; record → transcribe → store locally (PostgreSQL).
• Nginx as a shield: TLS/mTLS, rate-limits/WAF, redact PII before anything leaves.
• Strict RBAC, minimal LLM logging, auditable access.
• Abstracted adapters for LLM/telephony from day one to avoid hard lock-in.

If you must stay cloud-first for now
• Keep prompts/chains and vector indexes inside your perimeter; send only minimal context outward.
• Redact PII in Node.js middleware and at Nginx.
• Plan your exit: interchangeable adapters for LLM/STT/TTS so a provider swap doesn’t break production.

What a phone Voice AI Assistant actually is (with real-time)
Think of it as an LLM core (ChatGPT variants like GPT-4o/4.1), an orchestrator (LangChain, LangGraph), speech-to-text (STT) engines (Whisper, Vosk), and text-to-speech (TTS) engines (Coqui TTS, Piper) working together in real-time to handle the call and drive actions across your systems.

Appendix — drop in your Node.js skeleton (no secrets here)

import Fastify from 'fastify'; import WebSocket from 'ws'; import dotenv from 'dotenv'; import fastifyFormBody from '@fastify/formbody'; import fastifyWs from '@fastify/websocket';


// Load environment variables from .env file

dotenv.config({ path: '/var/www/twilio.solarneutrino.com/.env' });
// Retrieve the OpenAI API key from environment variables.

const { OPENAI_API_KEY } = process.env;
if (!OPENAI_API_KEY) {

    console.error('Missing OpenAI API key. Please set it in the .env file.');

    process.exit(1);

}
// Initialize Fastify

const fastify = Fastify();

fastify.register(fastifyFormBody);

fastify.register(fastifyWs);
// Constants

const SYSTEM_MESSAGE = 'Your name is Sophia. You are female. Your company, Solar Neutrino, provides marketing, SEO, and web development services. Answer any question and any language th

at you are asking. Try to make booking a schedule for your services. Use professional sellers scripts to get offers.';

const VOICE = 'sage';	//https://platform.openai.com/docs/guides/text-to-speech

const PORT = process.env.PORT || 5050; // Allow dynamic port assignment
// List of Event Types to log to the console. See the OpenAI Realtime API Documentation: https://platform.openai.com/docs/api-reference/realtime

const LOG_EVENT_TYPES = [

    'error',

    'response.content.done',

    'rate_limits.updated',

    'response.done',

    'input_audio_buffer.committed',

    'input_audio_buffer.speech_stopped',

    'input_audio_buffer.speech_started',

    'session.created'

];
// Show AI response elapsed timing calculations

const SHOW_TIMING_MATH = false;
// Root Route

fastify.get('/', async (request, reply) => {

    reply.send({ message: 'Twilio Media Stream Server is running!' });

});
// Route for Twilio to handle incoming calls

//  punctuation to improve text-to-speech translation

fastify.all('/incoming-call', async (request, reply) => {

    const twimlResponse = `

                          

                              Please wait while we connect your call to the A. I. voice assistant, powered by Solar Neutrino.
                              
                              O.K. you can start talking!

                              

                                  

                              

                          `;
    reply.type('text/xml').send(twimlResponse);

});
// WebSocket route for media-stream

fastify.register(async (fastify) => {

    fastify.get('/media-stream', { websocket: true }, (connection, req) => {

        console.log('Client connected');
        // Connection-specific state

        let streamSid = null;

        let latestMediaTimestamp = 0;

        let lastAssistantItem = null;

        let markQueue = [];

        let responseStartTimestampTwilio = null;
        const openAiWs = new WebSocket('wss://api.openai.com/v1/realtime?model=gpt-4o-realtime-preview-2024-10-01', {

            headers: {

                Authorization: `Bearer ${OPENAI_API_KEY}`,

                "OpenAI-Beta": "realtime=v1"

            }

        });
        // Control initial session with OpenAI

        const initializeSession = () => {

            const sessionUpdate = {

                type: 'session.update',

                session: {

                    turn_detection: { type: 'server_vad' },

                    input_audio_format: 'g711_ulaw',

                    output_audio_format: 'g711_ulaw',

                    voice: VOICE,

                    instructions: SYSTEM_MESSAGE,

                    modalities: ["text", "audio"],

                    temperature: 0.8,

                }

            };
            console.log('Sending session update:', JSON.stringify(sessionUpdate));

            openAiWs.send(JSON.stringify(sessionUpdate));
            // Uncomment the following line to have AI speak first:

            // sendInitialConversationItem();

        };
        // Send initial conversation item if AI talks first

        const sendInitialConversationItem = () => {

            const initialConversationItem = {

                type: 'conversation.item.create',

                item: {

                    type: 'message',

                    role: 'user',

                    content: [

                        {

                            type: 'input_text',

                            text: 'Greet the user with "Hello there! I am an AI voice assistant powered by Twilio and the OpenAI Realtime API. You can

 ask me for facts, jokes, or anything you can imagine. How can I help you?"'

                        }

                    ]
                }

            };
            if (SHOW_TIMING_MATH) console.log('Sending initial conversation item:', JSON.stringify(initialConversationItem));

            openAiWs.send(JSON.stringify(initialConversationItem));

            openAiWs.send(JSON.stringify({ type: 'response.create' }));

        };
        // Handle interruption when the caller's speech starts

        const handleSpeechStartedEvent = () => {

            if (markQueue.length > 0 && responseStartTimestampTwilio != null) {

                const elapsedTime = latestMediaTimestamp - responseStartTimestampTwilio;

                if (SHOW_TIMING_MATH) console.log(`Calculating elapsed time for truncation: ${latestMediaTimestamp} - ${responseStartTimestampTwilio}

= ${elapsedTime}ms`);
                if (lastAssistantItem) {

                    const truncateEvent = {

                        type: 'conversation.item.truncate',

                        item_id: lastAssistantItem,

                        content_index: 0,

                        audio_end_ms: elapsedTime

                    };

                    if (SHOW_TIMING_MATH) console.log('Sending truncation event:', JSON.stringify(truncateEvent));

                    openAiWs.send(JSON.stringify(truncateEvent));

                }
                connection.send(JSON.stringify({

                    event: 'clear',

                    streamSid: streamSid

                }));
                // Reset

                markQueue = [];

                lastAssistantItem = null;

                responseStartTimestampTwilio = null;

            }

        };
        // Send mark messages to Media Streams so we know if and when AI response playback is finished

        const sendMark = (connection, streamSid) => {

            if (streamSid) {

                const markEvent = {

                    event: 'mark',

                    streamSid: streamSid,

                    mark: { name: 'responsePart' }

                };

                connection.send(JSON.stringify(markEvent));

                markQueue.push('responsePart');

            }

        };
        // Open event for OpenAI WebSocket

        openAiWs.on('open', () => {

            console.log('Connected to the OpenAI Realtime API');

            setTimeout(initializeSession, 100);

        });
        // Listen for messages from the OpenAI WebSocket (and send to Twilio if necessary)

        openAiWs.on('message', (data) => {

            try {

                const response = JSON.parse(data);
                if (LOG_EVENT_TYPES.includes(response.type)) {

                    console.log(`Received event: ${response.type}`, response);

                }
                if (response.type === 'response.audio.delta' && response.delta) {

                    const audioDelta = {

                        event: 'media',

                        streamSid: streamSid,

                        media: { payload: response.delta }

                    };

                    connection.send(JSON.stringify(audioDelta));
                    // First delta from a new response starts the elapsed time counter

                    if (!responseStartTimestampTwilio) {

                        responseStartTimestampTwilio = latestMediaTimestamp;

                        if (SHOW_TIMING_MATH) console.log(`Setting start timestamp for new response: ${responseStartTimestampTwilio}ms`);

                    }
                    if (response.item_id) {

                        lastAssistantItem = response.item_id;

                    }
                    sendMark(connection, streamSid);

                }
                if (response.type === 'input_audio_buffer.speech_started') {

                    handleSpeechStartedEvent();

                }

            } catch (error) {

                console.error('Error processing OpenAI message:', error, 'Raw message:', data);

            }

        });
        // Handle incoming messages from Twilio

        connection.on('message', (message) => {

            try {

                const data = JSON.parse(message);
                switch (data.event) {

                    case 'media':

                        latestMediaTimestamp = data.media.timestamp;

                        if (SHOW_TIMING_MATH) console.log(`Received media message with timestamp: ${latestMediaTimestamp}ms`);

                        if (openAiWs.readyState === WebSocket.OPEN) {

                            const audioAppend = {

                                type: 'input_audio_buffer.append',

                                audio: data.media.payload

                            };

                            openAiWs.send(JSON.stringify(audioAppend));

                        }

                        break;

                    case 'start':

                        streamSid = data.start.streamSid;

                        console.log('Incoming stream has started', streamSid);
                        // Reset start and media timestamp on a new stream

                        responseStartTimestampTwilio = null;

                        latestMediaTimestamp = 0;

                        break;

                    case 'mark':

                        if (markQueue.length > 0) {

                            markQueue.shift();

                        }

                        break;

                    default:

                        console.log('Received non-media event:', data.event);

                        break;

                }

            } catch (error) {

                console.error('Error parsing message:', error, 'Message:', message);

            }

        });
        // Handle connection close

        connection.on('close', () => {

            if (openAiWs.readyState === WebSocket.OPEN) openAiWs.close();

            console.log('Client disconnected.');

        });
        // Handle WebSocket close and errors

        openAiWs.on('close', () => {

            console.log('Disconnected from the OpenAI Realtime API');

        });
        openAiWs.on('error', (error) => {

            console.error('Error in the OpenAI WebSocket:', error);

        });

    });

});

fastify.listen({ port: PORT }, (err) => { if (err) { console.error(err); process.exit(1); } console.log(`Server is listening on port ${PORT}`); });

Tags: security, Voice AI, phone AI assistant, real-time, Twilio, Asterisk, Node.js, Nginx, Laravel, Symfony, WordPress, Drupal, OpenAI API, Azure OpenAI, Anthropic Claude, AWS Bedrock, RAG, LangChain, LangGraph, PostgreSQL, PostGIS, pgvector, STT (Whisper, Vosk), TTS (Coqui TTS, Piper), call recording, transcription, on-prem, self-hosted LLM

LinkedIn Post Voice AI Assistant (Phone)

Fix Shared SMB Mounts on macOS Tahoe After Updates: Auto-Mount on Login Without Glitches

Joker — Sun, 05 Oct 2025 21:09:03 +0000

Fix Shared SMB Mounts on macOS Tahoe After Updates: Auto-Mount on Login Without Glitches

After a macOS Tahoe update, many admins discover their SMB shares no longer auto-mount at login, or they mount to unstable paths like /Volumes/share-1 and disappear between reboots. Finder items in “Login Items” are fragile, and scripting only mount_smbfs ignores your Keychain (and often prompts at the worst time).

This post gives you a battle-tested fix: a tiny Python script that:

Uses your existing Keychain credentials (no passwords in files).
Waits for the right network, confirms the server by ARP MAC, then mounts.
Handles Finder’s dynamic mount points by creating stable symlinks under ~/Network.
Runs as a user LaunchAgent, so it’s reliable across reboots and sleeps.

What we’ll build
A LaunchAgent that runs a Python script every 30 seconds (and on login). The script checks you’re on the expected subnet, confirms the target SMB server’s MAC via ARP, then mounts shares via Finder (so Keychain supplies the password). If Finder is stubborn, it falls back to mount_smbfs at a user-writable mount point. Finally, it drops deterministic symlinks under ~/Network so your paths don’t change.

1) One-time prep: save the credential in Keychain

Open Finder → ⌘K (Go → Connect to Server…).
Connect to smb://192.168.0.1/share (and any other share you need, e.g. scan).
Sign in as user user, check “Remember this password in my keychain”. Disconnect after it mounts.

Heads-up: The script never stores your password. It relies entirely on the saved Keychain item for smb://192.168.0.1.

2) Install the script

Create a small workspace and drop in mount_smb.py.

# create the folders
mkdir -p /Users/user/bin /Users/user/Network

# open an editor and paste the script below
nano /Users/user/bin/mount_smb.py

# make it executable
chmod +x /Users/user/bin/mount_smb.py

mount_smb.py

Python 2/3 compatible, standard library only.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function

import os, sys, time, subprocess, shlex, re, errno, datetime, socket, struct

# ------------------ CONFIG ------------------
CONFIG = {
    # SMB server and shares
    'SERVER_IP'   : '192.168.0.1',
    'SERVER_MAC'  : '00:11:22:33:44:55',   # any case / separators accepted
    'USERNAME'    : 'user',
    'SHARES'      : ['share', 'scan'],

    # Only act when the primary IPv4 is in this subnet
    'WIFI_SUBNET' : '192.168.0.0/24',

    # Paths
    'NETWORK_DIR' : os.path.expanduser('~/Network'),
    'LOG_PATH'    : os.path.expanduser('~/Library/Logs/mount_smb_python.log'),

    # Timing
    'ARP_RETRIES' : 10,   # ARP retries (1s apart)
    'MOUNT_TRIES' : 60,   # osascript attempts (1s apart)
}
# --------------------------------------------

def now(): return datetime.datetime.now().strftime("[%Y-%m-%d %H:%M:%S]")

def log(msg):
    line = u"{} {}".format(now(), msg)
    try:
        sys.stdout.write(line + "\n"); sys.stdout.flush()
    except: pass
    try:
        with open(CONFIG['LOG_PATH'], 'a') as f: f.write(line + "\n")
    except: pass

def run(cmd, shell=False):
    try:
        args = cmd if (shell or not isinstance(cmd, str)) else shlex.split(cmd)
        p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=shell)
        out, err = p.communicate(); rc = p.returncode
        if not isinstance(out, str): out = out.decode('utf-8', 'ignore')
        if not isinstance(err, str): err = err.decode('utf-8', 'ignore')
        return rc, out, err
    except OSError as e:
        return 127, "", str(e)

def ip_to_int(ip): return struct.unpack("!I", socket.inet_aton(ip))[0]
def cidr_match(ip, cidr):
    try:
        net, pfx = cidr.split('/'); pfx = int(pfx)
        mask = (0xffffffff << (32 - pfx)) & 0xffffffff
        return (ip_to_int(ip) & mask) == (ip_to_int(net) & mask)
    except: return False

def default_interface():
    rc, out, _ = run(['/sbin/route', '-n', 'get', 'default'])
    if rc != 0: return None
    m = re.search(r'interface:\s+([^\s]+)', out)
    return m.group(1) if m else None

def ipv4_for_iface(iface):
    if not iface: return None
    rc, out, _ = run(['/usr/sbin/ipconfig', 'getifaddr', iface])
    ip = out.strip()
    return ip if rc == 0 and re.match(r'^\d+\.\d+\.\d+\.\d+$', ip) else None

def normalize_mac(s):
    if not s: return ""
    s = re.sub(r'[^0-9a-f]', '', s.strip().lower())
    return ':'.join( for i in range(0, len(s), 2)])

def arp_mac_for_ip(ip):
    rc, out, _ = run(['/usr/sbin/arp', '-n', ip])
    if rc != 0: return ""
    m = re.search(r'\bat\s+([0-9a-fA-F:\- ]+)\s+on\s', out)
    return normalize_mac(m.group(1)) if m else ""

def ensure_dir(path):
    try: os.makedirs(path)
    except OSError as e:
        if e.errno != errno.EEXIST: raise

def mounted_path_for_share(server_ip, share_name):
    rc, out, _ = run(['/sbin/mount'])
    if rc != 0: return None
    pattern = re.compile(r'@{}/{}\s+on\s+(\S+)'.format(re.escape(server_ip), re.escape(share_name)))
    for line in out.splitlines():
        if '@{}/{}'.format(server_ip, share_name) in line:
            m = pattern.search(line)
            if m: return m.group(1)
    return None

def mount_via_osascript(server_ip, share_name, username):
    script = u'''try
mount volume "smb://{}/{}" as user name "{}"
end try'''.format(server_ip, share_name, username)
    rc, _, _ = run(['/usr/bin/osascript', '-e', script])
    return rc == 0

def mount_via_mount_smbfs(server_ip, share_name, username, dest):
    ensure_dir(dest)
    rc, _, err = run(['/sbin/mount_smbfs', '-f', '0644', '-d', '0755',
                      '//{}@{}/{}'.format(username, server_ip, share_name), dest])
    if rc != 0: log("mount_smbfs error for {}: rc={} err={}".format(share_name, rc, err.strip()))
    return rc == 0

def stable_link(link_path, target_path):
    try:
        if os.path.islink(link_path) or os.path.exists(link_path):
            cur = os.path.realpath(link_path)
            if cur == os.path.realpath(target_path): return
            try: os.remove(link_path)
            except: pass
        os.symlink(target_path, link_path)
    except Exception as e:
        log("symlink error: {} -> {} ({})".format(link_path, target_path, e))

def main():
    cfg = CONFIG
    ensure_dir(os.path.dirname(cfg['LOG_PATH']))
    ensure_dir(cfg['NETWORK_DIR']); ensure_dir(os.path.join(cfg['NETWORK_DIR'], '.mnt'))

    iface = default_interface()
    ip = ipv4_for_iface(iface)
    if not ip:
        log("No IPv4 yet (iface={}), exiting.".format(iface)); return 0
    if not cidr_match(ip, cfg['WIFI_SUBNET']):
        log("IPv4 {} not in {}, exiting.".format(ip, cfg['WIFI_SUBNET'])); return 0
    log("Default iface={} IPv4={} matches {} — proceeding.".format(iface, ip, cfg['WIFI_SUBNET']))

    want = normalize_mac(cfg['SERVER_MAC']); mac = ""
    for _ in range(cfg['ARP_RETRIES']):
        mac = arp_mac_for_ip(cfg['SERVER_IP'])
        if mac: break
        time.sleep(1)
    if want and mac and mac != want:
        log("ARP MAC mismatch for {}: saw {}, expected {} — exiting.".format(cfg['SERVER_IP'], mac, want)); return 0
    log("ARP {}: {}".format(cfg['SERVER_IP'], mac or "unresolved"))

    for share in cfg['SHARES']:
        mp = mounted_path_for_share(cfg['SERVER_IP'], share)
        if mp:
            log("{} already mounted at {}".format(share, mp))
            stable_link(os.path.join(cfg['NETWORK_DIR'], share), mp)
            continue

        log("Trying to mount {} via Finder (osascript)...".format(share))
        ok = False
        for attempt in range(cfg['MOUNT_TRIES']):
            mount_via_osascript(cfg['SERVER_IP'], share, cfg['USERNAME'])
            time.sleep(1)
            mp = mounted_path_for_share(cfg['SERVER_IP'], share)
            if mp: ok = True; break
            if (attempt + 1) % 10 == 0: log("Retry {} for {}...".format(attempt + 1, share))

        if not ok:
            log("Finder path did not attach; falling back to mount_smbfs for {}.".format(share))
            dest = os.path.join(cfg['NETWORK_DIR'], '.mnt', share)
            ok = mount_via_mount_smbfs(cfg['SERVER_IP'], share, cfg['USERNAME'], dest)
            mp = dest if ok else None

        if ok and mp:
            log("Mounted {} at {}".format(share, mp))
            stable_link(os.path.join(cfg['NETWORK_DIR'], share), mp)
        else:
            log("Failed to mount {}".format(share))
    return 0

if __name__ == '__main__':
    try: sys.exit(main())
    except KeyboardInterrupt: pass

3) LaunchAgent: run it at login and when the network changes

Create a user LaunchAgent:

cat > /Users/user/Library/LaunchAgents/com.user.mountsmb.py.plist <<'EOF'



  Labelcom.user.mountsmb.py
  ProgramArguments
    
    /opt/homebrew/bin/python3
    /Users/user/bin/mount_smb.py
  
  RunAtLoad
  KeepAliveNetworkState
  StartInterval30
  LimitLoadToSessionTypeAqua
  StandardOutPath/Users/user/Library/Logs/mount_smb_python.log
  StandardErrorPath/Users/user/Library/Logs/mount_smb_python.log

EOF

chmod 644 /Users/user/Library/LaunchAgents/com.user.mountsmb.py.plist

# (Optional) Intel Homebrew path:
# /usr/local/bin/python3 /Users/user/bin/mount_smb.py

Load or reload the agent:

launchctl bootout gui/$(id -u)/com.user.mountsmb.py 2>/dev/null || true
launchctl bootstrap gui/$(id -u) /Users/user/Library/LaunchAgents/com.user.mountsmb.py.plist
launchctl kickstart -k gui/$(id -u)/com.user.mountsmb.py

4) Verify

# check logs
tail -n 80 /Users/user/Library/Logs/mount_smb_python.log

# list stable paths regardless of Finder's dynamic mount points
ls -la  /Users/user/Network
ls -la  /Users/user/Network/share
ls -la  /Users/user/Network/scan

Troubleshooting

“env: python: No such file or directory” — Point ProgramArguments at the full python3 path (e.g. /opt/homebrew/bin/python3 on Apple Silicon).
Keychain prompts — Reconnect once in Finder to smb://192.168.0.1/share, check “Remember in Keychain”.
Wrong network — The script exits if your primary IPv4 isn’t in 192.168.0.0/24. Adjust WIFI_SUBNET in the config.
ARP mismatch — If your NAS has multiple NICs or failover, update SERVER_MAC.

Uninstall

launchctl bootout gui/$(id -u)/com.user.mountsmb.py 2>/dev/null || true
rm -f /Users/user/Library/LaunchAgents/com.user.mountsmb.py.plist
rm -f /Users/user/bin/mount_smb.py
rm -f /Users/user/Library/Logs/mount_smb_python.log

Result: your SMB shares mount cleanly after every reboot or network flap, paths stay stable via ~/Network/, and you never hard-code a secret.

Symfony VS Laravel

Joker — Sun, 02 Jun 2024 06:06:16 +0000

Laravel vs Symfony Comparison

Framework Features Comparison

Laravel 11	Symfony 7	Description
Artisan	Symfony Console	Command-line tools for managing the application, running migrations, generating code, etc.
Tinker	Symfony REPL (PsySH)	Interactive shell for working with the application from the command line.
Eloquent	Doctrine ORM	ORM (Object-Relational Mapping) for database interaction.
Facade DB	Doctrine DBAL	Interface for low-level database operations, below the ORM level.
Laravel Mix (uses npx)	Webpack Encore	Tools for compiling and managing frontend resources such as CSS and JavaScript.
Blade	Twig	Templating engines for generating HTML on the server side.
Laravel Scout	Elasticsearch (via package)	Tools for full-text search, integrating with Elasticsearch and other search systems.
Laravel Socialite	HWIOAuthBundle	Packages for integrating OAuth social authorizations.
Laravel Passport	LexikJWTAuthenticationBundle	API authentication implementations using tokens.
Laravel Horizon	Symfony Messenger	Tools for managing job queues and background processes.

Additional Features Comparison

Laravel 11	Symfony 7	Description
Paginate in Eloquent	Pagerfanta or KnpPaginator	Pagination of data, implemented in ORM or through third-party bundles.
Laravel Fortify (supports 2FA)	SchebTwoFactorBundle	Solutions for two-factor authentication (2FA) in web applications.
Laravel Sanctum	LexikJWTAuthenticationBundle	Solutions for API and SPA authentication, providing tokens and handling session states.

Directory Structure Comparison: Laravel vs Symfony

Laravel 11	Symfony 7	Description
/app	/src	Main application code, including controllers, models, and other classes.
/app/Http	/src/Controller	Controllers that manage the logic of incoming requests.
/app/Models	/src/Entity	Models in Laravel, entities in Symfony (used with Doctrine ORM).
/resources/views	/templates	User interface templates. Laravel uses Blade, Symfony uses Twig.
/resources/js	/assets/js	JavaScript files. Symfony uses Webpack Encore for managing assets.
/resources/sass	/assets/css	SASS/SCSS styles for frontend.
/bootstrap	/config/bootstrap.php	Bootstrap scripts in Laravel. Part of configuration in Symfony.
/config	/config	Application configuration files.
/database/migrations	/migrations	Database migrations.
/public	/public	Public root directory, the web application entry point.
/routes	/config/routes	Application routing definitions.
/storage	/var	Storage for log files, cache, and sessions.
/tests	/tests	Application tests.
/vendor	/vendor	Third-party libraries and dependencies installed via Composer.
.env	.env	Environment configuration file managing sensitive data and configurations.
composer.json	composer.json	Defines PHP dependencies and other Composer parameters.
package.json	package.json	Defines Node.js dependencies for frontend tools and libraries.

Laravel Command	Symfony Command	Description
php artisan list	php bin/console list	Displays all registered commands in the application.
php artisan make:model ModelName	php bin/console make:entity EntityName	Creates a new model in Laravel and a new entity in Symfony.
php artisan make:controller ControllerName	php bin/console make:controller ControllerName	Generates a new controller class in both frameworks.
php artisan make:event EventName	php bin/console make:event EventName	Creates a new event class in both Laravel and Symfony.
php artisan make:listener ListenerName —event=EventName	php bin/console make:subscriber EventName	Generates an event listener in Laravel and an event subscriber in Symfony.
php artisan migrate	php bin/console doctrine:migrations:migrate	Executes database migrations in both Laravel and Symfony.
php artisan serve	php bin/console server:run	Starts a development server for Laravel and Symfony applications.
php artisan route:list	php bin/console debug:router	Displays routes registered in the application for both frameworks.
php artisan cache:clear	php bin/console cache:clear	Clears the application cache in both Laravel and Symfony.
php artisan config:cache	php bin/console cache:warmup	Creates a cache file for faster configuration loading in Laravel and warms up the cache in Symfony.
php artisan queue:work	php bin/console messenger:consume	Starts the queue worker in Laravel and consumes messages from the message queue in Symfony.
php artisan make:middleware MiddlewareName	php bin/console make:middleware MiddlewareName	Generates a new middleware class in both Laravel and Symfony.
php artisan make:migration MigrationName	php bin/console make:migration	Creates a new database migration file in both frameworks.
php artisan db:seed	php bin/console doctrine:fixtures:load	Seeds the database with records in Laravel and loads data fixtures in Symfony.
php artisan tinker	php bin/console psysh	Provides an interactive shell for Laravel and Symfony, powered by PsySH.
php artisan optimize	php bin/console cache:warmup	Optimizes the framework loading in Laravel and preloads cache in Symfony.
php artisan schedule:run	php bin/console scheduler:execute	Runs the scheduled tasks configured in Laravel and Symfony.

MySQL vs PostgreSQL: Top Features

Joker — Tue, 23 Apr 2024 22:15:36 +0000

Let’s dive into the top 5 perks of using MySQL and PostgreSQL

Throwing in some cool stuff about locations and JSON. Plus, I’ll spotlight something unique to MySQL that PostgreSQL doesn’t offer. Let’s keep it chill and straightforward, like chatting on a sunny beach in Cali.

MySQL: The Go-To for Getting Things Rolling

Super User-Friendly: MySQL is like your friendly neighborhood guide. It’s super easy to set up and manage, which means you won’t spend hours figuring things out.
Costs? Nope, It’s free, man! Open-source helps keep those budget blues away.
Solid Rep for Large Traffic Handling: Scaling up? MySQL can handle the pressure like a pro surfer riding those big waves.
Widespread Love: With a massive community of users, finding help or resources is as easy as finding a taco truck in SoCal.
The Unique MySQL Replication: MySQL offers replication features that allow your data to be duplicated across multiple servers easily. PostgreSQL has replication too, but MySQL’s approach is super streamlined and has been in the game longer.

PostgreSQL: The Brainy Contender for Complex Needs

Data Integrity is King: If your project needs bulletproof accuracy, PostgreSQL is your go-to. It’s all about keeping your data clean and precise.
Advanced Data Types and Functions: What about JSON and locations? PostgreSQL effortlessly handles complex data like JSON and geospatial data, perfect for when you need more than just the basics.
Extensibility for Days: It’s like the custom surfboard of databases. You can tweak, extend, and make it exactly what you need.
PostGIS Extension: For those who need to manage and analyze location data, PostGIS makes PostgreSQL a powerhouse for geographic information systems (GIS).
Thriving Community and Open-Source: PostgreSQL is backed by a vibrant community, and being open-source means it’s continually evolving.

JSON and Location Handling: The Cool Extras

Both MySQL and PostgreSQL handle JSON, letting you store and query JSON data directly. This is handy for modern web apps where JSON is the leading data exchange language. Regarding location data, PostgreSQL, with its PostGIS extension, is like having GPS on steroids. It lets you do all sorts of spatial queries and analyses, which is incredible for any map-heavy app.

So, whether you’re building a startup from your garage or setting up a complex scientific database, choosing between MySQL and PostgreSQL depends on your needs. MySQL’s ease and efficiency make it perfect for business applications, while PostgreSQL’s robustness suits detailed, complex projects that need to handle intricate data with precision. Just pick the vibe that fits your project’s style!

Roman Primerov

Docker Commands Cheat Sheet for Backend Development

Joker — Fri, 19 Apr 2024 21:15:05 +0000

Docker Commands Cheat Sheet

This cheat sheet is a reminder for myself, which might come in handy in the daily life of a PHP and Node.js backend developer.

Container Management

List running containers: docker ps
List all containers (including stopped): docker ps -a
Create a container from an image without starting it: docker create
Rename a container: docker rename [container] [new-name]
Remove a container: docker rm [container], use -f to force remove a running container.
View logs for a container: docker logs [container], use -f --until=[interval] to display logs up to a certain point in time.
Update a container’s configuration: docker update [container]
Show container’s port mappings: docker port [container]
Show running processes in a container: docker top [container]
Show live resource usage statistics of a container: docker stats [container]
Show changes to files or directories on a container’s filesystem: docker diff [container]
Copy files to/from a container: docker cp [file-path] CONTAINER:[path]

Networking

View available networks: docker network ls
Remove a network: docker network rm [network]
Connect a container to a network: docker network connect [network] [container]
Disconnect a container from a network: docker network disconnect [network] [container]
Show detailed information about a network: docker network inspect [network]

Image Management

Create an image from a Dockerfile: docker build [dockerfile-path], use -t [name]:[tag] to tag it.
Pull an image from a registry: docker pull
Push an image to a registry: docker push
Save changes in a container as a new image: docker commit [container] [new-image]
View all locally stored top-level images: docker images
Remove an image: docker rmi
Show history of an image: docker history
Save an image to a tar archive file: docker save > [tar-file]
Remove unused images: docker image prune

The docker commands cheat sheet: #CheatSheetDocker

Managing Roles and Permissions in Laravel 11 with Spatie Permission

Joker — Fri, 15 Mar 2024 05:47:34 +0000

This guide provides a straightforward approach to setting up and managing roles and permissions in Laravel 11 using the Spatie Permission package.

Step 1: Install Spatie Laravel Permission

Start by installing the package via Composer and publishing its configurations:

composer require spatie/laravel-permission
php artisan vendor:publish --provider="Spatie\Permission\PermissionServiceProvider"
php artisan migrate

Step 2: Rollback the Last Migration

If needed, you can rollback the last migration with this command:

php artisan migrate:rollback --step=1

Step 3: Re-run Migrations

If tables were deleted or require recreation, run:

php artisan migrate

Step 4: Update the User Model

Ensure the User model uses the HasRoles trait from Spatie:


Step 5: Create and Run a Seeder for Roles and Permissions
Create a seeder then populate roles and permissions:
php artisan make:seeder RolesAndPermissionsSeeder
php artisan db:seed --class=RolesAndPermissionsSeeder

Here’s what your seeder might look like:
 'superadmin']);
        $roleAdmin = Role::create(['name' => 'admin']);
        $roleUser = Role::create(['name' => 'user']);
        // More roles setup...

        // Assign roles to users
        $userOne = User::where('email', 'j@solarneutrino.com')->first();
        if ($userOne) {
            $userOne->assignRole('superadmin');
        }

        $userTwo = User::where('email', 'user@gmail.com')->first();
        if ($userTwo) {
            $userTwo->assignRole('user');
        }
    }
}

Follow these steps to effectively manage roles and permissions in your Laravel 11 application using the Spatie Permission package.
Step 6: Auto-Assign ‘User’ Role on Registration
To automatically assign the «user» role to all newly registered users, you need to modify the registration handling method. This is usually the create method in the RegisterController.


Open the RegisterController.php file, typically located in the app/Http/Controllers/Auth directory.


Add the role assignment in the create method after creating a new user:
protected function create(array $data)
{
    $user = User::create([
        'name' => $data['name'],
        'email' => $data['email'],
        'password' => Hash::make($data['password']),
    ]);

    // Assigning the "user" role
    $user->assignRole('user');

    return $user;
}



This code snippet ensures that every new user is automatically granted the «user» role upon registration.
Step 7: Using @role and @hasrole Directives in Blade Templates
To manage content visibility based on user roles within Blade templates, Laravel’s Spatie Permission package provides two useful directives: @role and @hasrole. These directives help in rendering content conditionally based on the user’s roles.
Examples:

@role('superadmin')
    This text can see user from Superadmin group
@endrole


@hasrole('superadmin')
    This text can see user from Superadmin group
@endhasrole


@role('user')
    This text can see user from User group
@endrole


@hasrole('user')
    This text can see user from User group
@endhasrole

Explanations:

@role: This directive checks if the current authenticated user has one or more specified roles. If multiple roles are passed (separated by commas), it returns true if the user has at least one of them. In the provided examples, only one role is specified, so the behavior is similar to @hasrole.
@hasrole: This directive strictly checks if the user has the specified role. It’s ideal for situations where you need to verify the presence of only one specific role. This directive always takes only one role at a time.

These directives are instrumental in controlling what content a user can see based on their roles, enhancing security and user experience by tailoring the UI to meet individual user permissions.
Step 8: Applying Roles to Routes or Route Groups
In Laravel 11, the structure for handling middleware has changed significantly, including the deprecation of the app/Http/Kernel.php file. Middleware can now be applied directly in the routing files such as web.php or api.php. Here’s how to set up and use Spatie Permission Middleware to restrict route access to users with specific roles.
Registering and Applying Middleware
You can register your middleware directly in the routing file. Below is a step-by-step guide on how to apply the Spatie Permission Middleware directly to your routes:

Add the Middleware Namespace:
At the beginning of your routing file (e.g., routes/web.php), add the namespace for the middleware:



Apply Middleware to a Route:
Apply the middleware directly to the routes as follows:
get('/contact-messages', function () {
        return view('contact-messages');
    })->name('contact-messages');
?>

Note that we pass the RoleMiddleware class with the role parameter (superadmin) directly into the middleware array.


Laravel 10, 9, …
To secure routes based on user roles, Laravel allows the application of middleware to individual routes or groups of routes. Using Spatie’s permission package, you can enforce role-based access controls effectively.
Applying Roles to a Single Route:
use Illuminate\Support\Facades\Route;

// Ensure you have registered the 'role' middleware in your old version Laravel - Kernel.php after Laravel 11 it can be seeder class or another tinker way. 
Route::get('/admin', function () {
    return view('admin.dashboard');
})->middleware('role:admin');

This route is accessible only to users who have the ‘admin’ role. If a user without this role tries to access it, they will be redirected as defined by your middleware handling.
Applying Roles to a Route Group:
use Illuminate\Support\Facades\Route;

Route::middleware(['role:admin'])->group(function () {
    Route::get('/admin/dashboard', function() {
        return view('admin.dashboard');
    });
    Route::get('/admin/settings', function() {
        return view('admin.settings');
    });
});

This group of routes is secured with the ‘admin’ role, ensuring that all routes within this group require a user to be an ‘admin’ to gain access. This method is particularly effective for sectioning parts of your application that should be restricted to users with specific roles.
Note: It’s important to ensure that your Kernel.php file is properly configured to recognize the Spatie middleware. Add the Spatie middleware to your $routeMiddleware array if it’s not already present:
protected $routeMiddleware = [
    // other middleware
    'role' => \Spatie\Permission\Middlewares\RoleMiddleware::class,
];

Following these best practices not only enhances the security of your application by ensuring proper role-based access control but also aligns with Spatie’s documentation, ensuring you are implementing features in the recommended manner.
For example:
Utilized Laravel Breeze for authentication with frontend-designed Tailwind CSS and Spatie for role-based access control. Integrated Laravel Sanctum for secure token-based API and Laravel Multidomain middleware for simpler project integration. Enhanced security by hosting the admin panel on a separate domain (admin.solarneutrino.com) and (solarneutrino.com). Implemented a contact form with functionalities for email notifications, logging via Eloquent MySQL, and Telegram alerts. Infrastructure set up on EC2, utilizing Route 53 for DNS management and AWS SES for email dispatch.

Заметки

🧭 Guide: Building 4 synced SVG shapes that morph into one smiley (no JS)

What we’re building

Why it works (big ideas)

Step-by-step (kid-friendly)

Troubleshooting checklist

Production code for CodePen

CSS

☎️ Voice AI Assistant (phone) on AWS + Node.js + Nginx for Laravel / Symfony / WordPress / Drupal — easy to ship, harder to secure (security, real-time)

Fix Shared SMB Mounts on macOS Tahoe After Updates: Auto-Mount on Login Without Glitches

Fix Shared SMB Mounts on macOS Tahoe After Updates: Auto-Mount on Login Without Glitches

1) One-time prep: save the credential in Keychain

2) Install the script

mount_smb.py

3) LaunchAgent: run it at login and when the network changes

4) Verify

Troubleshooting

Uninstall

Symfony VS Laravel

Laravel vs Symfony Comparison

Framework Features Comparison

Additional Features Comparison

Directory Structure Comparison: Laravel vs Symfony

MySQL vs PostgreSQL: Top Features

Let’s dive into the top 5 perks of using MySQL and PostgreSQL

MySQL: The Go-To for Getting Things Rolling

PostgreSQL: The Brainy Contender for Complex Needs

JSON and Location Handling: The Cool Extras

Docker Commands Cheat Sheet for Backend Development

Docker Commands Cheat Sheet

Container Management

Networking

Image Management

Managing Roles and Permissions in Laravel 11 with Spatie Permission

Step 1: Install Spatie Laravel Permission

Step 2: Rollback the Last Migration

Step 3: Re-run Migrations

Step 4: Update the User Model

Step 5: Create and Run a Seeder for Roles and Permissions

Step 6: Auto-Assign ‘User’ Role on Registration

Step 7: Using @role and @hasrole Directives in Blade Templates

Examples:

Step 8: Applying Roles to Routes or Route Groups

Registering and Applying Middleware

Laravel 10, 9, …

Applying Roles to a Single Route:

Applying Roles to a Route Group:

Node.js vs Go vs Laravel: 5 Advantages in Microservices Development

Node.js

Go

Laravel

Conclusion

Curl Benefits for Web Developers

As a Web Developer, Here Are the TOP 10 Reasons Why «curl» Is Beneficial in an SSH Console Environment:

1. API and Web Service Testing :

2. File Downloading :

3. Task Automation :

4. Information Gathering :

5. Website and Server Monitoring :

6. Simulation of User Agent and IP Spoofing :

7. Security Testing :

8. Handling Cookies and Sessions :

9. Network Diagnostics and Troubleshooting :

10. Support for Multiple Protocols :

What a Full Stack Web Developer’s Portfolio Looks Like on Laravel + AWS Architecture with SEO Optimized Code and UX/UI Design