@fitlab-ai/agent-infra 0.8.4 → 0.9.0

package/dist/lib/server/process-control.js

@@ -1,66 +1,44 @@
 import fs from 'node:fs';
-import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
 import { loadServerConfig } from './config.js';
 import { runDaemon } from './daemon.js';
+import { getProcessStartTime, isProcessAlive, processIdentityMatches, readProcessState, removePidFileIfMatches, writePidRecord } from './process-state.js';
+export { isProcessAlive } from './process-state.js';
 export function buildStopCommand(pid, platform) {
     if (platform === 'win32') {
         return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };
     }
     return { kind: 'signal', signal: 'SIGTERM' };
 }
-// Liveness check that treats an exited-but-unreaped daemon as dead.
-//
-// The daemon is spawned detached and re-parented to init when `ai server start`
-// exits. After it terminates, `process.kill(pid, 0)` still succeeds until init
-// reaps the zombie. On Linux we therefore also check /proc state so status/stop
-// /start don't treat an already-exited daemon as running. macOS reaps orphans
-// via launchd and Windows has no zombies, so the kill(pid, 0) result is enough.
-export function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-    }
-    catch (error) {
-        // EPERM means the process exists but we may not signal it → still alive.
-        return error.code === 'EPERM';
-    }
-    if (process.platform === 'linux') {
-        try {
-            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
-            // The process state is the first token after the parenthesised comm.
-            const state = stat.slice(stat.lastIndexOf(')') + 1).trim().charAt(0);
-            if (state === 'Z')
-                return false;
-        }
-        catch {
-            return false; // /proc entry vanished → not alive
-        }
-    }
-    return true;
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
 }
-function readPid(pidFile) {
-    try {
-        const raw = fs.readFileSync(pidFile, 'utf8').trim();
-        const pid = Number.parseInt(raw, 10);
-        return Number.isInteger(pid) && pid > 0 ? pid : null;
-    }
-    catch {
-        return null;
-    }
+async function waitForProcessIdentity(pid, timeoutMs = 2000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const startTime = getProcessStartTime(pid);
+        if (startTime !== null)
+            return { version: 1, pid, startTime };
+        await delay(25);
+    }
+    return null;
 }
-function removePidFile(pidFile) {
+function terminateIfMatching(record) {
+    if (!processIdentityMatches(record))
+        return;
+    const command = buildStopCommand(record.pid, process.platform);
     try {
-        fs.unlinkSync(pidFile);
+        if (command.kind === 'exec')
+            execFileSync(command.command, command.args);
+        else
+            process.kill(record.pid, command.signal);
     }
     catch {
-        // Already gone.
+        // Best effort cleanup for a daemon whose PID record could not be published.
     }
 }
-function delay(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
 function enabledAdapterNames(config) {
     return Object.entries(config.adapters)
         .filter(([, adapter]) => adapter?.enabled === true)
@@ -69,15 +47,13 @@ function enabledAdapterNames(config) {
 export async function start({ foreground = false } = {}) {
     const config = loadServerConfig();
     const pidPath = config.pidFile;
-    // Zombie PID cleanup: a stale PID file from a crashed daemon must not block a
-    // fresh start.
-    const existing = readPid(pidPath);
-    if (existing !== null && isProcessAlive(existing)) {
-        process.stdout.write(`server already running (pid ${existing})\n`);
+    const existing = readProcessState(pidPath);
+    if (existing.kind === 'running') {
+        process.stdout.write(`server already running (pid ${existing.record.pid})\n`);
         return;
     }
-    if (existing !== null) {
-        removePidFile(pidPath);
+    if (existing.kind !== 'missing') {
+        removePidFileIfMatches(pidPath, existing.snapshot);
     }
     if (foreground) {
         await runDaemon();
@@ -98,47 +74,64 @@ export async function start({ foreground = false } = {}) {
     if (typeof child.pid !== 'number') {
         throw new Error('server: failed to spawn daemon process');
     }
-    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
-    fs.writeFileSync(pidPath, `${child.pid}\n`);
-    process.stdout.write(`server started (pid ${child.pid})\n`);
+    // The initial check, spawn, and record publication are not a mutually
+    // exclusive transaction. Atomic publication keeps the record complete, but
+    // a separate locking design is required to serialize concurrent starts.
+    const record = await waitForProcessIdentity(child.pid);
+    if (record === null || !processIdentityMatches(record)) {
+        throw new Error('server: unable to verify spawned daemon process identity');
+    }
+    try {
+        writePidRecord(pidPath, record);
+    }
+    catch (error) {
+        terminateIfMatching(record);
+        throw error;
+    }
+    process.stdout.write(`server started (pid ${record.pid})\n`);
 }
 export async function stop() {
     const config = loadServerConfig();
-    const pid = readPid(config.pidFile);
-    if (pid === null) {
+    const state = readProcessState(config.pidFile);
+    if (state.kind === 'missing') {
         process.stdout.write('server is not running (no pid file)\n');
         return;
     }
-    if (!isProcessAlive(pid)) {
-        removePidFile(config.pidFile);
+    if (state.kind !== 'running') {
+        removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server is not running (removed stale pid file)\n');
         return;
     }
-    const command = buildStopCommand(pid, process.platform);
+    const { record } = state;
+    if (!processIdentityMatches(record)) {
+        removePidFileIfMatches(config.pidFile, state.snapshot);
+        process.stdout.write('server is not running (removed stale pid file)\n');
+        return;
+    }
+    const command = buildStopCommand(record.pid, process.platform);
     if (command.kind === 'exec') {
         execFileSync(command.command, command.args);
     }
     else {
-        process.kill(pid, command.signal);
+        process.kill(record.pid, command.signal);
         const deadline = Date.now() + 5000;
-        while (isProcessAlive(pid) && Date.now() < deadline) {
+        while (isProcessAlive(record.pid) && Date.now() < deadline) {
             await delay(100);
         }
-        if (isProcessAlive(pid)) {
-            process.kill(pid, 'SIGKILL');
+        if (isProcessAlive(record.pid) && processIdentityMatches(record)) {
+            process.kill(record.pid, 'SIGKILL');
         }
     }
-    removePidFile(config.pidFile);
-    process.stdout.write(`server stopped (pid ${pid})\n`);
+    removePidFileIfMatches(config.pidFile, state.snapshot);
+    process.stdout.write(`server stopped (pid ${record.pid})\n`);
 }
 export function status() {
     const config = loadServerConfig();
-    const pid = readPid(config.pidFile);
-    if (pid === null || !isProcessAlive(pid)) {
+    const state = readProcessState(config.pidFile);
+    if (state.kind !== 'running') {
+        if (state.kind !== 'missing')
+            removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server: stopped\n');
-        if (pid !== null) {
-            process.stdout.write(`  (stale pid file references pid ${pid})\n`);
-        }
         return;
     }
     let startedAt = 'unknown';
@@ -150,7 +143,7 @@ export function status() {
     }
     const adapters = enabledAdapterNames(config);
     process.stdout.write(`server: running\n` +
-        `  pid: ${pid}\n` +
+        `  pid: ${state.record.pid}\n` +
         `  started: ${startedAt}\n` +
         `  adapters: ${adapters.length > 0 ? adapters.join(', ') : '(none)'}\n` +
         `  pid file: ${config.pidFile}\n` +

package/dist/lib/server/process-state.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+export function parseLinuxProcessStat(raw) {
+    const closeParen = raw.lastIndexOf(')');
+    if (closeParen < 0)
+        return null;
+    const fields = raw.slice(closeParen + 1).trim().split(/\s+/);
+    const state = fields[0];
+    const startTime = fields[19];
+    if (typeof state !== 'string' || state.length !== 1 || !/^\d+$/.test(startTime ?? '')) {
+        return null;
+    }
+    return { state, startTime: startTime };
+}
+export function buildProcessStartTimeQuery(pid, platform) {
+    if (platform === 'darwin') {
+        return { command: 'ps', args: ['-p', String(pid), '-o', 'lstart='] };
+    }
+    if (platform === 'win32') {
+        const script = `$process = Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}'; ` +
+            `if ($null -ne $process) { $process.CreationDate.ToUniversalTime().ToString('o') }`;
+        return {
+            command: 'powershell.exe',
+            args: ['-NoProfile', '-NonInteractive', '-Command', script]
+        };
+    }
+    return null;
+}
+export function isProcessAlive(pid, platform = process.platform) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    if (platform === 'linux') {
+        try {
+            const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${pid}/stat`, 'utf8'));
+            return stat !== null && stat.state !== 'Z';
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+export function getProcessStartTime(pid, platform = process.platform) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    if (platform === 'linux') {
+        try {
+            const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${pid}/stat`, 'utf8'));
+            return stat !== null && stat.state !== 'Z' ? stat.startTime : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!isProcessAlive(pid, platform))
+        return null;
+    const query = buildProcessStartTimeQuery(pid, platform);
+    if (query === null)
+        return null;
+    try {
+        const output = execFileSync(query.command, query.args, { encoding: 'utf8' }).trim();
+        if (output.length === 0)
+            return null;
+        if (platform === 'win32') {
+            const timestamp = new Date(output);
+            return Number.isNaN(timestamp.getTime()) ? null : timestamp.toISOString();
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}
+function parsePidRecord(raw) {
+    const trimmed = raw.trim();
+    if (/^[1-9]\d*$/.test(trimmed)) {
+        const pid = Number(trimmed);
+        return Number.isSafeInteger(pid) ? { kind: 'legacy', pid } : { kind: 'invalid' };
+    }
+    try {
+        const value = JSON.parse(trimmed);
+        if (value !== null &&
+            value.version === 1 &&
+            Number.isSafeInteger(value.pid) &&
+            (value.pid ?? 0) > 0 &&
+            typeof value.startTime === 'string' &&
+            value.startTime.length > 0) {
+            return {
+                kind: 'record',
+                record: { version: 1, pid: value.pid, startTime: value.startTime }
+            };
+        }
+    }
+    catch {
+        // Invalid JSON is an invalid PID record.
+    }
+    return { kind: 'invalid' };
+}
+export function readProcessState(pidFile) {
+    let snapshot;
+    try {
+        snapshot = fs.readFileSync(pidFile, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { kind: 'missing', snapshot: null };
+        return { kind: 'invalid', snapshot: '' };
+    }
+    const parsed = parsePidRecord(snapshot);
+    if (parsed.kind === 'invalid')
+        return { kind: 'invalid', snapshot };
+    if (parsed.kind === 'legacy')
+        return { kind: 'legacy', snapshot, pid: parsed.pid };
+    const currentStartTime = getProcessStartTime(parsed.record.pid);
+    if (currentStartTime === null || currentStartTime !== parsed.record.startTime) {
+        return { kind: 'stale', snapshot, record: parsed.record };
+    }
+    return { kind: 'running', snapshot, record: parsed.record };
+}
+export function writePidRecord(pidFile, record) {
+    fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+    const temporary = `${pidFile}.${process.pid}.${Math.random().toString(16).slice(2)}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(record)}\n`);
+        fs.renameSync(temporary, pidFile);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(temporary);
+        }
+        catch {
+            // The temporary file was never created or was already renamed.
+        }
+        throw error;
+    }
+}
+export function removePidFileIfMatches(pidFile, expectedSnapshot) {
+    if (expectedSnapshot === null)
+        return false;
+    try {
+        if (fs.readFileSync(pidFile, 'utf8') !== expectedSnapshot)
+            return false;
+        fs.unlinkSync(pidFile);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function removePidRecordIfMatches(pidFile, expected) {
+    const state = readProcessState(pidFile);
+    if (state.kind !== 'running')
+        return false;
+    if (state.record.pid !== expected.pid || state.record.startTime !== expected.startTime)
+        return false;
+    return removePidFileIfMatches(pidFile, state.snapshot);
+}
+export function processIdentityMatches(record) {
+    return getProcessStartTime(record.pid) === record.startTime;
+}
+//# sourceMappingURL=process-state.js.map

package/dist/lib/server/protocol.js

@@ -20,16 +20,16 @@ export function commandHelp() {
         '/sandbox ls',
         '/sandbox show {ref}',
         '/sandbox vm status',
-        '/task decisions {ref}',
-        '/task log {ref}',
+        '/task decisions [--task {ref}] [--item {selector}]',
+        '/task log [--task {ref}]',
         '/task ls',
-        '/task show {ref}',
-        '/task status {ref}',
+        '/task show [--task {ref}]',
+        '/task status [--task {ref}]',
         'Write:',
         '/sandbox create {ref}',
         '/sandbox start {ref}',
         'Exec:',
-        '/decide {task-ref} {HD-id} {decision}',
+        '/decide [--task {ref}] --item {ordinal|ledger-id} [--needs-implementation true|false] {decision}',
         '/run create-task {description}',
         '/run {skill} {task-ref}'
     ].join('\n');

package/dist/lib/task/activity-log.js

@@ -0,0 +1,61 @@
+const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
+const NEXT_H2_RE = /^##\s/;
+const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*\*(.+?)\*\* by (.+?) — (.*)$/;
+const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
+function parseActivityLog(content) {
+    const section = locateActivityLog(content);
+    return section ? { sectionFound: true, entries: section.entries } : { sectionFound: false, entries: [] };
+}
+function locateActivityLog(content) {
+    const lines = content.split('\n');
+    const headings = lines.map((line, index) => HEADING_RE.test(line) ? index : -1).filter((index) => index >= 0);
+    if (headings.length !== 1)
+        return null;
+    const i = headings[0];
+    let end = lines.length;
+    for (let j = i + 1; j < lines.length; j += 1) {
+        if (NEXT_H2_RE.test(lines[j])) {
+            end = j;
+            break;
+        }
+    }
+    const bodyLines = lines.slice(i + 1, end);
+    const parsed = [];
+    for (const line of bodyLines) {
+        const m = ENTRY_RE.exec(line);
+        if (!m)
+            continue;
+        parsed.push({ entry: { time: m[1], step: m[2], agent: m[3], note: m[4] }, epoch: Date.parse(m[1].replace(' ', 'T')), order: parsed.length });
+    }
+    parsed.sort((a, b) => a.epoch - b.epoch || a.order - b.order);
+    return { heading: HEADING_RE.exec(lines[i])[1], body: bodyLines.join('\n').replace(/^\n+|\n+$/g, ''), entries: parsed.map((item) => item.entry) };
+}
+function appendActivityEntry(section, entry) {
+    const line = `- ${entry.time} — **${entry.step}** by ${entry.agent} — ${entry.note}`;
+    return section.body ? `${section.body}\n${line}` : line;
+}
+function pairEntries(entries) {
+    const rows = [];
+    const open = new Map();
+    for (const entry of entries) {
+        const started = STARTED_SUFFIX_RE.test(entry.step);
+        const base = entry.step.replace(STARTED_SUFFIX_RE, '');
+        if (started) {
+            const row = { step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note };
+            rows.push(row);
+            const queue = open.get(base) ?? [];
+            queue.push(row);
+            open.set(base, queue);
+        }
+        else {
+            const pending = open.get(base)?.shift();
+            if (pending)
+                Object.assign(pending, { done: entry.time, agent: entry.agent, note: entry.note });
+            else
+                rows.push({ step: base, agent: entry.agent, started: '', done: entry.time, note: entry.note });
+        }
+    }
+    return rows;
+}
+export { parseActivityLog, locateActivityLog, appendActivityEntry, pairEntries };
+//# sourceMappingURL=activity-log.js.map