@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.101

package/dist/runtime/commands/servers.js

@@ -0,0 +1,236 @@
+/**
+ * PR H (2026-06-05): `/servers` slash command — list + stop server-
+ * started processes the operator can't otherwise kill from inside
+ * the REPL.
+ *
+ * Customer pain (CEO 2026-06-05): Hiroshi launched a Vite dev server
+ * via `server_start` tool (PID 45800 on :5173), persona answered
+ * "use `pugi stop`" — but `/stop <persona>` halts a persona agent,
+ * not a server process. Server kept running until manual
+ * `kill 45800`.
+ *
+ * Fix: surface the existing `server_start` meta files (which already
+ * persist `.pugi/runs/srv-<uuid>/server.json` per the
+ * server-tools.ts spec) as a first-class operator-facing list +
+ * kill command. The `server_stop` TOOL already exists for LLM
+ * dispatch (SIGTERM → grace → SIGKILL ladder via
+ * `dispatchServerStop`); we wire it through to a slash command so
+ * the operator no longer needs to copy PIDs out of agent text.
+ *
+ * Surface:
+ *
+ *   /servers                        → table of tracked servers
+ *   /servers stop <runId>           → kill one by run id (srv-...)
+ *   /servers stop <pid>             → kill one by pid (numeric)
+ *   /servers stop all               → kill every alive tracked srv
+ *
+ * Everything is best-effort. A missing `.pugi/runs/` dir = empty
+ * list, not an error. A stale `server.json` for a process that
+ * already exited stays listed as `dead` so the operator can see it
+ * happened.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+function runsDir(workspaceRoot) {
+    return join(workspaceRoot, '.pugi', 'runs');
+}
+function isAlive(pid, killImpl) {
+    try {
+        killImpl(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read every `<runs>/srv-<uuid>/server.json` and project к `ServerEntry`.
+ * Pure: takes the workspace + kill impl (для liveness check), returns
+ * a stable-sorted (oldest-first) list. Failure modes:
+ *   - missing runs dir → []
+ *   - unreadable / malformed JSON → entry omitted (no throw)
+ *   - meta carries no pid → entry kept but `alive=false`
+ */
+export function listServers(workspaceRoot, killImpl = (pid, signal) => {
+    process.kill(pid, signal);
+}) {
+    const dir = runsDir(workspaceRoot);
+    if (!existsSync(dir))
+        return [];
+    let names = [];
+    try {
+        names = readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && e.name.startsWith('srv-'))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const runId of names) {
+        const metaPath = join(dir, runId, 'server.json');
+        if (!existsSync(metaPath))
+            continue;
+        let meta;
+        try {
+            meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        const pid = typeof meta['pid'] === 'number' ? meta['pid'] : null;
+        out.push({
+            runId,
+            pid,
+            port: typeof meta['port'] === 'number' ? meta['port'] : null,
+            command: typeof meta['command'] === 'string' ? meta['command'] : null,
+            startedAt: typeof meta['startedAt'] === 'string' ? meta['startedAt'] : null,
+            healthStatus: typeof meta['healthStatus'] === 'number' ? meta['healthStatus'] : null,
+            alive: pid !== null ? isAlive(pid, killImpl) : false,
+        });
+    }
+    return out;
+}
+/**
+ * Kill one or more servers. Strategy:
+ *   - `target === 'all'`  — kill every alive entry
+ *   - target matches `srv-...` — match by runId (exact)
+ *   - target is numeric    — match by pid
+ *
+ * Uses the same SIGTERM → 5s grace → SIGKILL ladder as the
+ * `server_stop` tool. Failures silent (entry stays listed as alive
+ * on next `/servers` if SIGKILL also fails — operator escalates
+ * manually).
+ */
+export async function stopServers(workspaceRoot, target, options) {
+    const killImpl = options.killImpl ??
+        ((pid, signal) => {
+            process.kill(pid, signal);
+        });
+    const entries = listServers(workspaceRoot, killImpl);
+    if (entries.length === 0)
+        return { kind: 'empty' };
+    const targets = [];
+    if (target === 'all') {
+        targets.push(...entries.filter((e) => e.alive));
+    }
+    else if (/^srv-/.test(target)) {
+        const hit = entries.find((e) => e.runId === target);
+        if (!hit)
+            return { kind: 'not-found', query: target };
+        targets.push(hit);
+    }
+    else if (/^\d+$/.test(target)) {
+        const wanted = Number(target);
+        const hit = entries.find((e) => e.pid === wanted);
+        if (!hit)
+            return { kind: 'not-found', query: target };
+        targets.push(hit);
+    }
+    else {
+        return { kind: 'not-found', query: target };
+    }
+    if (targets.length === 0)
+        return { kind: 'empty' };
+    const killed = [];
+    let notFound = 0;
+    for (const entry of targets) {
+        if (entry.pid === null) {
+            notFound += 1;
+            continue;
+        }
+        if (!isAlive(entry.pid, killImpl)) {
+            // already dead — treat as success (operator's intent matched)
+            killed.push(entry);
+            continue;
+        }
+        try {
+            killImpl(entry.pid, 'SIGTERM');
+        }
+        catch {
+            // SIGTERM refused → escalate
+        }
+        // Grace window: poll for exit up to 5s.
+        const deadline = Date.now() + 5_000;
+        while (Date.now() < deadline) {
+            if (!isAlive(entry.pid, killImpl))
+                break;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        if (isAlive(entry.pid, killImpl)) {
+            try {
+                killImpl(entry.pid, 'SIGKILL');
+            }
+            catch {
+                notFound += 1;
+                continue;
+            }
+        }
+        killed.push(entry);
+    }
+    return { kind: 'stopped', killed, notFound };
+}
+/**
+ * Slash entry. The session dispatcher calls this с the parsed verdict
+ * and an IO sink that pipes lines к the REPL system pane.
+ */
+export async function runServersCommand(mode, io, options) {
+    if (mode.kind === 'list') {
+        const entries = listServers(options.workspaceRoot, options.killImpl);
+        renderList(entries, io);
+        return { kind: 'listed', entries };
+    }
+    const result = await stopServers(options.workspaceRoot, mode.target, options);
+    renderStopResult(result, io);
+    return result;
+}
+function renderList(entries, io) {
+    if (entries.length === 0) {
+        io.write('No tracked servers (.pugi/runs/srv-* empty).');
+        return;
+    }
+    io.write(`Tracked servers (${entries.length}):`);
+    for (const e of entries) {
+        const status = e.alive ? 'alive' : 'dead';
+        const port = e.port !== null ? `:${e.port}` : '';
+        const pid = e.pid !== null ? `pid=${e.pid}` : 'pid=?';
+        const cmd = e.command ? truncate(e.command, 60) : '<unknown>';
+        io.write(`  ${e.runId}  [${status}]  ${pid}  ${port}  ${cmd}`);
+    }
+    io.write('Use `/servers stop <runId|pid|all>` to terminate.');
+}
+function renderStopResult(result, io) {
+    switch (result.kind) {
+        case 'empty':
+            io.write('No alive servers to stop.');
+            return;
+        case 'not-found':
+            io.write(`No server matches '${result.query}'. Run \`/servers\` to list.`);
+            return;
+        case 'stopped': {
+            if (result.killed.length === 0) {
+                io.write(`Stop dispatched but 0 servers terminated (${result.notFound} miss).`);
+                return;
+            }
+            io.write(`Stopped ${result.killed.length} server(s):`);
+            for (const e of result.killed) {
+                io.write(`  ${e.runId}  pid=${e.pid ?? '?'}${e.port !== null ? ` :${e.port}` : ''}`);
+            }
+            if (result.notFound > 0) {
+                io.write(`(${result.notFound} entry skipped — no pid or kill failed)`);
+            }
+            return;
+        }
+        case 'error':
+            io.write(`Error: ${result.message}`);
+            return;
+        case 'listed':
+            // not used in stop path
+            return;
+    }
+}
+function truncate(s, max) {
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+//# sourceMappingURL=servers.js.map

package/dist/runtime/commands/sessions.js

@@ -0,0 +1,163 @@
+/**
+ * `pugi sessions` extensions — .
+ *
+ * The legacy `pugi sessions` handler lives inline in `runtime/cli.ts`
+ * (it predates the per-command runner pattern). This module exposes the
+ * new sub-commands the L9 sprint adds:
+ *
+ *  - `pugi sessions undo-rewind [<session-id>]`
+ *      Append an inverse marker that nullifies the latest 'rewind'
+ *      marker on the target session. Operator escape hatch: nothing
+ *      is destroyed, the masked range simply becomes visible again.
+ *
+ * Wire pattern matches `runCompactCommand` / `runRewindCommand`: one
+ * structured payload + one human line per invocation, returned to the
+ * caller for the JSON path.
+ */
+import { homedir } from 'node:os';
+import { slugForCwd } from '../../core/repl/history.js';
+import { appendRewindMarker, findLatestActiveRewind, } from '../../core/checkpoint/rewinder.js';
+import { loadFromStore } from '../../core/checkpoint/resumer.js';
+import { SqliteSessionStore, resolveProjectStoreDir, } from '../../core/repl/store/session-store.js';
+/**
+ * Sub-command router. The caller passes the full positional args; we
+ * peel `args[0]` as the sub-command name and forward the tail. Unknown
+ * sub-commands surface a usage hint at exit code 2.
+ */
+export async function runSessionsCommand(args, ctx) {
+    const sub = args[0];
+    if (sub === 'undo-rewind') {
+        return runUndoRewind(args.slice(1), ctx);
+    }
+    // Other sub-commands (the legacy `pugi sessions` list path) are
+    // owned by runtime/cli.ts — return null so the caller knows to fall
+    // through to that handler.
+    return null;
+}
+async function runUndoRewind(args, ctx) {
+    const explicitId = args[0] && !args[0].startsWith('--') ? args[0] : undefined;
+    const slug = slugForCwd(ctx.workspaceRoot);
+    let store = ctx.store ?? null;
+    let sessionId = ctx.sessionId ?? explicitId ?? null;
+    let storeOpenedHere = false;
+    if (store === null) {
+        sessionId = sessionId ?? (await pickMostRecentSessionIdReadOnly(slug));
+        if (!sessionId) {
+            return emit(ctx, {
+                command: 'sessions',
+                sub: 'undo-rewind',
+                status: 'failed_no_session',
+                reason: 'No session to undo-rewind. Start a REPL with `pugi`.',
+            });
+        }
+        const opened = await openLiveStore(slug, sessionId);
+        if (!opened) {
+            return emit(ctx, {
+                command: 'sessions',
+                sub: 'undo-rewind',
+                status: 'failed_store',
+                sessionId,
+                reason: 'Could not open local session store (lock held by another REPL?).',
+            });
+        }
+        store = opened;
+        storeOpenedHere = true;
+    }
+    else if (sessionId === null) {
+        const rows = await store.listSessions({ project: slug, limit: 1, status: 'active' });
+        if (rows.length === 0) {
+            return emit(ctx, {
+                command: 'sessions',
+                sub: 'undo-rewind',
+                status: 'failed_no_session',
+                reason: 'No active session to undo-rewind.',
+            });
+        }
+        sessionId = rows[0].id;
+    }
+    try {
+        const loaded = await loadFromStore(store, sessionId);
+        if (!loaded) {
+            return emit(ctx, {
+                command: 'sessions',
+                sub: 'undo-rewind',
+                status: 'failed_no_session',
+                sessionId,
+                reason: `Session '${sessionId}' not found.`,
+            });
+        }
+        const latest = findLatestActiveRewind(loaded.rawEvents);
+        if (latest === null) {
+            return emit(ctx, {
+                command: 'sessions',
+                sub: 'undo-rewind',
+                status: 'noop_no_rewind',
+                sessionId,
+                reason: 'No active rewind to undo on this session.',
+            }, 'No active rewind to undo.');
+        }
+        const fromEventIndex = loaded.rawEvents.length;
+        await appendRewindMarker({
+            store,
+            mode: 'undo-rewind',
+            toEventIndex: latest.payload.toEventIndex,
+            fromEventIndex,
+            turnsRewound: latest.payload.turnsRewound,
+            reason: 'undo',
+            ...(ctx.now !== undefined ? { now: ctx.now } : {}),
+        });
+        return emit(ctx, {
+            command: 'sessions',
+            sub: 'undo-rewind',
+            status: 'undone',
+            sessionId,
+            undoneTurns: latest.payload.turnsRewound,
+        }, `Undid the latest rewind (${latest.payload.turnsRewound} turn${latest.payload.turnsRewound === 1 ? '' : 's'} restored).`);
+    }
+    finally {
+        if (storeOpenedHere && store) {
+            try {
+                await store.close();
+            }
+            catch {
+                /* idempotent */
+            }
+        }
+    }
+}
+function emit(ctx, payload, text) {
+    const human = text ?? payload.reason ?? `sessions ${payload.sub}: ${payload.status}`;
+    ctx.writeOutput(payload, human);
+    return payload;
+}
+async function openLiveStore(projectSlug, sessionId) {
+    try {
+        const store = new SqliteSessionStore({ projectSlug, home: homedir() });
+        await store.open({
+            id: sessionId,
+            workspaceRoot: process.cwd(),
+            projectSlug,
+        });
+        return store;
+    }
+    catch {
+        return null;
+    }
+}
+async function pickMostRecentSessionIdReadOnly(projectSlug) {
+    try {
+        const dir = resolveProjectStoreDir(projectSlug, homedir());
+        const view = await SqliteSessionStore.openReadOnly(dir);
+        try {
+            const rows = await view.list({ project: projectSlug, limit: 1, status: 'active' });
+            return rows.length > 0 ? rows[0].id : null;
+        }
+        finally {
+            await view.close();
+        }
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=sessions.js.map