@pasko70/pibo 2.5.2 → 3.0.1

package/dist/mcp/daemon.js

@@ -1,21 +1,102 @@
 /**
  * MCP-CLI Daemon - Background worker that maintains persistent MCP connections
  *
- * This is spawned as a detached process and manages a Unix socket for IPC.
- * It maintains the MCP server connection and forwards requests from CLI invocations.
+ * This is spawned as a detached process and manages a Unix socket on POSIX or
+ * a named pipe on Windows. It maintains the MCP server connection and forwards
+ * requests from CLI invocations.
  */
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { closeSync, existsSync, fstatSync, futimesSync, linkSync, mkdirSync, openSync, readFileSync, readlinkSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { createServer } from 'node:net';
 import { dirname } from 'node:path';
 import { callTool, connectToServer, listTools, } from './client.js';
-import { debug, getConfigHash, getDaemonTimeoutMs, getPidPath, getSocketDir, getSocketPath, } from './config.js';
+import { debug, getConfigHash, getDaemonClaimPath, getDaemonTimeoutMs, getPidPath, getSocketDir, getSocketPath, usesFilesystemSocket, } from './config.js';
+function hashBuffer(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+/**
+ * Read an OS process creation identity that changes when a PID is reused.
+ * Linux exposes the kernel start tick, executable, and argv through procfs.
+ * Other platforms fail closed: callers may request graceful endpoint shutdown,
+ * but they must not authorize a PID signal from unverifiable metadata.
+ */
+export function readProcessIdentity(pid) {
+    if (process.platform !== 'linux' || !Number.isInteger(pid) || pid <= 0) {
+        return null;
+    }
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
+        const commandEnd = stat.lastIndexOf(') ');
+        if (commandEnd === -1)
+            return null;
+        const fieldsAfterCommand = stat.slice(commandEnd + 2).trim().split(/\s+/);
+        const startToken = fieldsAfterCommand[19];
+        if (!startToken)
+            return null;
+        return {
+            platform: 'linux',
+            startToken,
+            executable: readlinkSync(`/proc/${pid}/exe`),
+            commandHash: hashBuffer(readFileSync(`/proc/${pid}/cmdline`)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function processIdentityMatches(actual, expected) {
+    return Boolean(actual &&
+        expected &&
+        actual.platform === expected.platform &&
+        actual.startToken === expected.startToken &&
+        actual.executable === expected.executable &&
+        actual.commandHash === expected.commandHash);
+}
+export function daemonProcessIdentityMatches(expected) {
+    return processIdentityMatches(readProcessIdentity(expected.pid), expected.processIdentity);
+}
+function getFileIdentity(path) {
+    try {
+        const stat = statSync(path);
+        return {
+            device: stat.dev,
+            inode: stat.ino,
+            size: stat.size,
+            modifiedAt: stat.mtimeMs,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function fileIdentityMatches(actual, expected) {
+    return Boolean(actual &&
+        expected &&
+        actual.device === expected.device &&
+        actual.inode === expected.inode &&
+        actual.size === expected.size &&
+        actual.modifiedAt === expected.modifiedAt);
+}
+function getQuarantinePath(path) {
+    return `${path}.delete-${process.pid}-${Date.now()}-${randomUUID()}`;
+}
+function restoreQuarantinedFile(path, quarantinePath) {
+    try {
+        if (existsSync(quarantinePath) && !existsSync(path)) {
+            renameSync(quarantinePath, path);
+        }
+    }
+    catch {
+        // A newer owner may already occupy the canonical path.
+    }
+}
 // ============================================================================
 // PID File Management
 // ============================================================================
 /**
  * Write PID file with config hash for stale detection
  */
-export function writePidFile(serverName, configHash) {
+export function writePidFile(serverName, configHash, generation) {
     const pidPath = getPidPath(serverName);
     const dir = dirname(pidPath);
     if (!existsSync(dir)) {
@@ -24,15 +105,21 @@ export function writePidFile(serverName, configHash) {
     const content = {
         pid: process.pid,
         configHash,
+        generation,
         startedAt: new Date().toISOString(),
+        serverName,
+        processIdentity: readProcessIdentity(process.pid) ?? undefined,
     };
-    writeFileSync(pidPath, JSON.stringify(content), { mode: 0o600 });
+    writeFileSync(pidPath, JSON.stringify(content), {
+        flag: 'wx',
+        mode: 0o600,
+    });
+    return content;
 }
 /**
  * Read PID file content
  */
-export function readPidFile(serverName) {
-    const pidPath = getPidPath(serverName);
+export function readPidFilePath(pidPath) {
     if (!existsSync(pidPath)) {
         return null;
     }
@@ -44,34 +131,261 @@ export function readPidFile(serverName) {
         return null;
     }
 }
+export function readPidFile(serverName) {
+    return readPidFilePath(getPidPath(serverName));
+}
+export function daemonIdentityMatches(actual, expected) {
+    return Boolean(actual &&
+        expected &&
+        actual.pid === expected.pid &&
+        actual.configHash === expected.configHash &&
+        actual.generation === expected.generation);
+}
+export function pidFileIdentityMatches(actual, expected) {
+    return Boolean(daemonIdentityMatches(actual, expected) &&
+        actual?.startedAt === expected?.startedAt &&
+        actual?.serverName === expected?.serverName &&
+        ((actual?.processIdentity === undefined &&
+            expected?.processIdentity === undefined) ||
+            processIdentityMatches(actual?.processIdentity, expected?.processIdentity)));
+}
+function quarantinePidFilePath(pidPath, expected) {
+    const quarantinePath = getQuarantinePath(pidPath);
+    try {
+        const current = readPidFilePath(pidPath);
+        if (!current || (expected && !pidFileIdentityMatches(current, expected))) {
+            return null;
+        }
+        renameSync(pidPath, quarantinePath);
+        const moved = readPidFilePath(quarantinePath);
+        if (moved && (!expected || pidFileIdentityMatches(moved, expected))) {
+            return quarantinePath;
+        }
+        restoreQuarantinedFile(pidPath, quarantinePath);
+        return null;
+    }
+    catch {
+        restoreQuarantinedFile(pidPath, quarantinePath);
+        return null;
+    }
+}
+export function removePidFilePath(pidPath, expected) {
+    const quarantinePath = quarantinePidFilePath(pidPath, expected);
+    if (!quarantinePath)
+        return false;
+    try {
+        unlinkSync(quarantinePath);
+        return true;
+    }
+    catch {
+        restoreQuarantinedFile(pidPath, quarantinePath);
+        return false;
+    }
+}
 /**
  * Remove PID file
  */
-export function removePidFile(serverName) {
-    const pidPath = getPidPath(serverName);
+export function removePidFile(serverName, expected) {
+    return removePidFilePath(getPidPath(serverName), expected);
+}
+export function writeOwnershipFileExclusive(path, content) {
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    const publicationPath = `${path}.publish-${process.pid}-${randomUUID()}`;
     try {
-        if (existsSync(pidPath)) {
-            unlinkSync(pidPath);
+        writeFileSync(publicationPath, JSON.stringify(content), {
+            flag: 'wx',
+            mode: 0o600,
+        });
+        linkSync(publicationPath, path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EEXIST') {
+            return false;
+        }
+        throw error;
+    }
+    finally {
+        try {
+            unlinkSync(publicationPath);
+        }
+        catch {
+            // The temporary publication name may never have been created.
         }
     }
+}
+export function readOwnershipFilePath(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
     catch {
-        // Ignore errors during cleanup
+        return null;
+    }
+}
+export function getOwnershipFileAgeMs(path) {
+    try {
+        return Math.max(0, Date.now() - statSync(path).mtimeMs);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Refresh one ownership generation through an opened inode. A concurrent path
+ * replacement is never refreshed because the descriptor remains bound to the
+ * original file and the canonical inode is checked before reporting success.
+ */
+export function refreshOwnershipFile(path, expectedGeneration, expectedOwnerNonce) {
+    let handle;
+    try {
+        handle = openSync(path, 'r');
+        const opened = fstatSync(handle);
+        const current = JSON.parse(readFileSync(handle, { encoding: 'utf8' }));
+        if (current.generation !== expectedGeneration ||
+            (expectedOwnerNonce !== undefined &&
+                current.ownerNonce !== expectedOwnerNonce)) {
+            return false;
+        }
+        const now = new Date();
+        futimesSync(handle, now, now);
+        const canonical = statSync(path);
+        return canonical.dev === opened.dev && canonical.ino === opened.ino;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (handle !== undefined) {
+            try {
+                closeSync(handle);
+            }
+            catch {
+                // A failed close cannot make the ownership refresh authoritative.
+            }
+        }
+    }
+}
+export function removeOwnershipFile(path, expectedGeneration) {
+    const quarantinePath = getQuarantinePath(path);
+    try {
+        const current = readOwnershipFilePath(path);
+        if (!current || current.generation !== expectedGeneration) {
+            return false;
+        }
+        // Rename is the atomic compare-and-delete boundary. If another process
+        // replaced the path after our first read, inspect the moved file and put it
+        // back instead of unlinking that process's ownership record.
+        renameSync(path, quarantinePath);
+        const moved = readOwnershipFilePath(quarantinePath);
+        if (moved?.generation === expectedGeneration) {
+            unlinkSync(quarantinePath);
+            return true;
+        }
+        if (!existsSync(path))
+            renameSync(quarantinePath, path);
+        return false;
+    }
+    catch {
+        restoreQuarantinedFile(path, quarantinePath);
+        return false;
+    }
+}
+/** Remove an old malformed ownership file without racing a replacement. */
+export function removeMalformedOwnershipFile(path, minimumAgeMs) {
+    const expectedFileIdentity = getFileIdentity(path);
+    const ageMs = getOwnershipFileAgeMs(path);
+    if (!expectedFileIdentity ||
+        ageMs === null ||
+        ageMs < minimumAgeMs ||
+        readOwnershipFilePath(path) !== null) {
+        return false;
+    }
+    const quarantinePath = getQuarantinePath(path);
+    try {
+        renameSync(path, quarantinePath);
+        if (readOwnershipFilePath(quarantinePath) === null &&
+            fileIdentityMatches(getFileIdentity(quarantinePath), expectedFileIdentity)) {
+            unlinkSync(quarantinePath);
+            return true;
+        }
+        restoreQuarantinedFile(path, quarantinePath);
+        return false;
+    }
+    catch {
+        restoreQuarantinedFile(path, quarantinePath);
+        return false;
     }
 }
 /**
  * Remove socket file
  */
 export function removeSocketFile(serverName) {
+    if (!usesFilesystemSocket()) {
+        return true;
+    }
     const socketPath = getSocketPath(serverName);
     try {
         if (existsSync(socketPath)) {
             unlinkSync(socketPath);
         }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function daemonStateOwnershipMatches(ownership) {
+    return (readOwnershipFilePath(ownership.path)?.generation === ownership.generation);
+}
+/**
+ * Atomically acquire one matching PID generation before deleting its endpoint.
+ * The caller must hold the per-server ownership claim for the whole operation.
+ */
+export function removeDaemonState(serverName, expected, ownership) {
+    if (!daemonStateOwnershipMatches(ownership))
+        return false;
+    const pidPath = getPidPath(serverName);
+    const quarantinePath = quarantinePidFilePath(pidPath, expected);
+    if (!quarantinePath)
+        return false;
+    if (!daemonStateOwnershipMatches(ownership) || existsSync(pidPath)) {
+        if (existsSync(pidPath)) {
+            try {
+                unlinkSync(quarantinePath);
+            }
+            catch {
+                // A later cleanup can remove the quarantined old generation.
+            }
+        }
+        else {
+            restoreQuarantinedFile(pidPath, quarantinePath);
+        }
+        return false;
+    }
+    if (!removeSocketFile(serverName)) {
+        restoreQuarantinedFile(pidPath, quarantinePath);
+        return false;
+    }
+    try {
+        unlinkSync(quarantinePath);
+        return true;
     }
     catch {
-        // Ignore errors during cleanup
+        // The endpoint is already gone. Keep the old PID generation unavailable
+        // rather than republishing metadata for a stopped daemon.
+        return false;
     }
 }
+export function removeUntrackedEndpoint(serverName, ownership) {
+    if (!daemonStateOwnershipMatches(ownership) ||
+        existsSync(getPidPath(serverName))) {
+        return false;
+    }
+    return removeSocketFile(serverName);
+}
 /**
  * Check if a process is running
  */
@@ -84,12 +398,12 @@ export function isProcessRunning(pid) {
         return false;
     }
 }
-/**
- * Kill a process by PID
- */
-export function killProcess(pid) {
+/** Signal only the process creation identity recorded by the daemon itself. */
+export function terminateDaemonProcess(expected) {
+    if (!daemonProcessIdentityMatches(expected))
+        return false;
     try {
-        process.kill(pid, 'SIGTERM');
+        process.kill(expected.pid, 'SIGTERM');
         return true;
     }
     catch {
@@ -102,7 +416,7 @@ export function killProcess(pid) {
 /**
  * Main daemon entry point - run as detached background process
  */
-export async function runDaemon(serverName, config) {
+export async function runDaemon(serverName, config, generation) {
     const socketPath = getSocketPath(serverName);
     const configHash = getConfigHash(config);
     const timeoutMs = getDaemonTimeoutMs();
@@ -110,8 +424,10 @@ export async function runDaemon(serverName, config) {
     let mcpClient = null;
     let server = null;
     const activeConnections = new Set();
+    let identity = null;
+    let cleanupPromise = null;
     // Cleanup function
-    const cleanup = async () => {
+    const performCleanup = async () => {
         debug(`[daemon:${serverName}] Shutting down...`);
         if (idleTimer) {
             clearTimeout(idleTimer);
@@ -147,11 +463,35 @@ export async function runDaemon(serverName, config) {
             }
             server = null;
         }
-        // Clean up files
-        removeSocketFile(serverName);
-        removePidFile(serverName);
+        // Self-cleanup uses the same per-server ownership boundary as elected
+        // clients. If another owner is replacing this daemon, leave cleanup to it.
+        if (identity) {
+            const claimPath = getDaemonClaimPath(serverName);
+            const cleanupClaim = {
+                ownerPid: process.pid,
+                generation: randomUUID(),
+                configHash: identity.configHash,
+                startedAt: new Date().toISOString(),
+                serverName,
+            };
+            if (writeOwnershipFileExclusive(claimPath, cleanupClaim)) {
+                try {
+                    removeDaemonState(serverName, identity, {
+                        path: claimPath,
+                        generation: cleanupClaim.generation,
+                    });
+                }
+                finally {
+                    removeOwnershipFile(claimPath, cleanupClaim.generation);
+                }
+            }
+        }
         debug(`[daemon:${serverName}] Cleanup complete`);
     };
+    const cleanup = () => {
+        cleanupPromise ??= performCleanup();
+        return cleanupPromise;
+    };
     // Reset idle timer
     const resetIdleTimer = () => {
         if (idleTimer) {
@@ -177,10 +517,9 @@ export async function runDaemon(serverName, config) {
     if (!existsSync(socketDir)) {
         mkdirSync(socketDir, { recursive: true, mode: 0o700 });
     }
-    // Remove stale socket if exists
-    removeSocketFile(serverName);
-    // Write PID file
-    writePidFile(serverName, configHash);
+    // The spawning client owns the startup claim and removes stale state before
+    // launch. Exclusive PID creation makes an ownership bug fail closed.
+    identity = writePidFile(serverName, configHash, generation);
     // Connect to MCP server
     try {
         debug(`[daemon:${serverName}] Connecting to MCP server...`);
@@ -207,6 +546,17 @@ export async function runDaemon(serverName, config) {
             };
         }
         debug(`[daemon:${serverName}] Request: ${request.type} (${request.id})`);
+        if (request.type !== 'ping' &&
+            request.generation !== identity?.generation) {
+            return {
+                id: request.id,
+                success: false,
+                error: {
+                    code: 'STALE_DAEMON_GENERATION',
+                    message: 'Daemon generation changed; reconnect before retrying',
+                },
+            };
+        }
         if (!mcpClient) {
             return {
                 id: request.id,
@@ -217,7 +567,7 @@ export async function runDaemon(serverName, config) {
         try {
             switch (request.type) {
                 case 'ping':
-                    return { id: request.id, success: true, data: 'pong' };
+                    return { id: request.id, success: true, data: identity };
                 case 'listTools': {
                     const tools = await listTools(mcpClient.client);
                     return { id: request.id, success: true, data: tools };
@@ -264,14 +614,28 @@ export async function runDaemon(serverName, config) {
             };
         }
     };
-    // Start Unix socket server
+    // Start the Unix domain socket or Windows named-pipe server
     try {
         server = createServer((socket) => {
             activeConnections.add(socket);
             debug(`[daemon:${serverName}] Client connected`);
+            let requestBuffer = '';
+            socket.setEncoding('utf8');
             socket.on('data', async (data) => {
-                const response = await handleRequest(Buffer.isBuffer(data) ? data : Buffer.from(data));
-                socket.write(`${JSON.stringify(response)}\n`);
+                requestBuffer += data;
+                if (requestBuffer.length > 1024 * 1024) {
+                    socket.destroy(new Error('Daemon request exceeds 1 MiB'));
+                    return;
+                }
+                while (requestBuffer.includes('\n')) {
+                    const newlineIndex = requestBuffer.indexOf('\n');
+                    const requestText = requestBuffer.slice(0, newlineIndex);
+                    requestBuffer = requestBuffer.slice(newlineIndex + 1);
+                    if (!requestText.trim())
+                        continue;
+                    const response = await handleRequest(Buffer.from(requestText));
+                    socket.write(`${JSON.stringify(response)}\n`);
+                }
             });
             socket.on('close', () => {
                 activeConnections.delete(socket);
@@ -292,8 +656,7 @@ export async function runDaemon(serverName, config) {
         debug(`[daemon:${serverName}] Listening on ${socketPath}`);
         // Start idle timer
         resetIdleTimer();
-        // Signal readiness by writing to stdout (parent will read this)
-        console.log('DAEMON_READY');
+        // The client detects readiness by pinging the IPC endpoint.
     }
     catch (error) {
         console.error(`[daemon:${serverName}] Failed to start socket server:`, error.message);
@@ -308,8 +671,9 @@ export async function runDaemon(serverName, config) {
 if (process.argv[2] === '--daemon') {
     const serverName = process.argv[3];
     const configJson = process.argv[4];
-    if (!serverName || !configJson) {
-        console.error('Usage: daemon.ts --daemon <serverName> <configJson>');
+    const generation = process.argv[5];
+    if (!serverName || !configJson || !generation) {
+        console.error('Usage: daemon.ts --daemon <serverName> <configJson> <generation>');
         process.exit(1);
     }
     let config;
@@ -320,7 +684,7 @@ if (process.argv[2] === '--daemon') {
         console.error('Invalid config JSON');
         process.exit(1);
     }
-    runDaemon(serverName, config).catch((error) => {
+    runDaemon(serverName, config, generation).catch((error) => {
         console.error('Daemon failed:', error);
         process.exit(1);
     });

package/dist/plugins/builtin.js

@@ -367,8 +367,8 @@ export const piboCorePlugin = definePiboPlugin({
             name: "session.fork_candidates",
             description: "Return user messages that can be used as fork targets.",
             slashCommands: ["fork-candidates"],
-            execute(context) {
-                return { messages: context.getForkCandidates() };
+            async execute(context) {
+                return { messages: await context.getForkCandidates() };
             },
         });
         api.registerGatewayAction({

package/dist/plugins/codex-native.js

@@ -1,5 +1,6 @@
 import { CODEX_NATIVE_ADAPTER_ID, CODEX_NATIVE_AGENT_RUNTIME_DRIVER, } from "../agent-runtimes/codex-native/adapter.js";
 import { InitialSessionContextBuilder } from "../core/profiles.js";
+import { createOpenAiCodexSpeechProvider } from "../speech/openai-codex.js";
 import { definePiboPlugin } from "./registry.js";
 export const CODEX_NATIVE_RUNTIME_INSTANCE_ID = "codex-native";
 export const CODEX_NATIVE_PROFILE_NAME = "codex-native";
@@ -13,6 +14,7 @@ export const piboCodexNativePlugin = definePiboPlugin({
             adapterId: CODEX_NATIVE_ADAPTER_ID,
             displayName: "Native Codex App Server",
         });
+        api.registerSpeechProvider(createOpenAiCodexSpeechProvider());
         api.registerProfile({
             name: CODEX_NATIVE_PROFILE_NAME,
             description: "Native Codex App Server profile. Distinct from the Pi-backed Codex compatibility profile.",