@bytetrue/byspace 0.17.0 → 0.18.0

package/node_modules/@bytetrue/server/dist/server/server/agent/providers/pi/subagent-session-tailer.js

@@ -0,0 +1,212 @@
+import { open, stat } from "node:fs/promises";
+import { mapPiSubagentStatus } from "./agent-subagents.js";
+import { PiHistoryMapper } from "./history-mapper.js";
+import { resolvePiSessionsDir, walkJsonlFiles } from "./session-descriptor.js";
+export const PI_SUBAGENT_TERMINAL_STATUSES = ["completed", "failed", "canceled"];
+const DEFAULT_POLL_MS = 1000;
+const LOCATE_RETRY_MS = 5000;
+const TERMINAL_DRAIN_GRACE_MS = 3000;
+/**
+ * Extract the tailer-relevant fields from a pi-subagent report record. The subagent id is
+ * required (it keys the tailer); session references start the tail, status tracks the end.
+ * Status-only snapshots matter too: they flip the entry to terminal so the tail stops.
+ */
+export function parsePiSubagentTailerSnapshot(record) {
+    if (typeof record !== "object" || record === null)
+        return null;
+    const source = record;
+    const subagentId = readString(source.id);
+    if (!subagentId)
+        return null;
+    const snapshot = { subagentId };
+    for (const key of ["sessionId", "sessionFile", "cwd", "status"]) {
+        const value = source[key];
+        if (typeof value === "string" && value.trim())
+            snapshot[key] = value;
+    }
+    return snapshot.sessionId || snapshot.sessionFile || snapshot.cwd || snapshot.status
+        ? snapshot
+        : null;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+async function drainPiSessionTailer(tailer, onTimeline) {
+    const info = await stat(tailer.file).catch(() => null);
+    if (!info?.isFile())
+        return;
+    if (info.size < tailer.offset) {
+        // File shrank (recreated): restart from the beginning with fresh mapper state.
+        tailer.offset = 0;
+        tailer.mapper = new PiHistoryMapper("pi");
+    }
+    if (info.size === tailer.offset)
+        return;
+    const handle = await open(tailer.file, "r");
+    try {
+        const length = info.size - tailer.offset;
+        const buffer = Buffer.alloc(length);
+        // A short read means the file was truncated between stat and read; parse only
+        // the bytes that actually arrived.
+        const { bytesRead } = await handle.read(buffer, 0, length, tailer.offset);
+        const text = buffer.toString("utf8", 0, bytesRead);
+        const lastNewline = text.lastIndexOf("\n");
+        if (lastNewline === -1)
+            return;
+        const chunk = text.slice(0, lastNewline + 1);
+        tailer.offset += Buffer.byteLength(chunk);
+        for (const line of chunk.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (typeof entry !== "object" || entry === null)
+                continue;
+            const message = entry.message;
+            if (typeof message !== "object" || message === null)
+                continue;
+            const timestamp = readString(entry.timestamp) ?? undefined;
+            const events = tailer.mapper.mapMessages([message]);
+            for (const event of events) {
+                if (event.type === "timeline") {
+                    onTimeline(event.item, timestamp);
+                }
+            }
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function locatePiSubagentSessionFile(sessionId, options = {}) {
+    const sessionsDir = await resolvePiSessionsDir({
+        cwd: options.cwd ?? undefined,
+        env: options.env ?? process.env,
+        homeDir: options.homeDir,
+    });
+    const suffix = `_${sessionId}.jsonl`;
+    const files = await walkJsonlFiles(sessionsDir);
+    return files.find((file) => file.endsWith(suffix)) ?? null;
+}
+export class PiSubagentSessionTailers {
+    constructor(options) {
+        this.entries = new Map();
+        this.timer = null;
+        this.queue = Promise.resolve();
+        this.options = options;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.timer = setInterval(() => {
+            void this.tick();
+        }, DEFAULT_POLL_MS);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    update(agentId, snapshot) {
+        const subagentId = snapshot.subagentId;
+        const key = `${agentId}\u0000${subagentId}`;
+        let entry = this.entries.get(key);
+        if (!entry) {
+            entry = {
+                agentId,
+                subagentId,
+                sessionId: null,
+                sessionFile: null,
+                cwd: null,
+                tailer: null,
+                lastLocateAttempt: 0,
+                terminalAt: null,
+            };
+            this.entries.set(key, entry);
+            this.start();
+        }
+        if (snapshot.sessionId)
+            entry.sessionId = snapshot.sessionId;
+        if (snapshot.sessionFile)
+            entry.sessionFile = snapshot.sessionFile;
+        if (snapshot.cwd)
+            entry.cwd = snapshot.cwd;
+        const status = mapPiSubagentStatus(snapshot.status ?? "");
+        if (status &&
+            PI_SUBAGENT_TERMINAL_STATUSES.includes(status) &&
+            entry.terminalAt === null) {
+            entry.terminalAt = Date.now();
+        }
+        // No reopen-on-running: reports have no ordering guarantee, so a stale running
+        // snapshot must not resurrect a finished subagent's tail. New launches are new ids.
+    }
+    removeAgent(agentId) {
+        for (const [key, entry] of this.entries) {
+            if (entry.agentId === agentId)
+                this.entries.delete(key);
+        }
+    }
+    dispose() {
+        this.stop();
+        this.entries.clear();
+    }
+    /**
+     * Drain every entry once. Timer and manual (test) ticks serialize through a promise
+     * chain instead of skipping, so an awaited tick never no-ops behind an in-flight one.
+     */
+    tick() {
+        const run = this.queue.then(() => this.drain());
+        this.queue = run.catch(() => { });
+        return run;
+    }
+    async drain() {
+        const now = Date.now();
+        for (const [key, entry] of this.entries) {
+            if (!entry.tailer && now - entry.lastLocateAttempt >= LOCATE_RETRY_MS) {
+                entry.lastLocateAttempt = now;
+                entry.tailer = await this.locate(entry);
+            }
+            if (entry.tailer) {
+                try {
+                    await drainPiSessionTailer(entry.tailer, (item, timestamp) => {
+                        this.options.emit(entry.agentId, {
+                            kind: "timeline",
+                            id: entry.subagentId,
+                            item,
+                            ...(timestamp ? { timestamp } : {}),
+                        });
+                    });
+                }
+                catch {
+                    // Transient read failures (rotation, permissions): retry next tick.
+                }
+            }
+            if (entry.terminalAt !== null &&
+                now >= entry.terminalAt + (this.options.terminalGraceMs ?? TERMINAL_DRAIN_GRACE_MS)) {
+                this.entries.delete(key);
+            }
+        }
+    }
+    async locate(entry) {
+        const file = entry.sessionFile ??
+            (entry.sessionId
+                ? await locatePiSubagentSessionFile(entry.sessionId, {
+                    cwd: entry.cwd,
+                    env: this.options.env,
+                    homeDir: this.options.homeDir,
+                })
+                : null);
+        if (!file)
+            return null;
+        return { file, offset: 0, mapper: new PiHistoryMapper("pi") };
+    }
+}
+//# sourceMappingURL=subagent-session-tailer.js.map

package/node_modules/@bytetrue/server/dist/server/server/bootstrap.d.ts

@@ -34,6 +34,12 @@ import { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js
 import { type ManagedProcessRegistry } from "./managed-processes/managed-processes.js";
 import { type HostnamesConfig } from "./hostnames.js";
 import { type DaemonAuthConfig } from "./auth.js";
+/**
+ * Local, token-gated snapshots reported by the BySpace-installed subagent extension;
+ * deliberately skips daemon auth. The manager is created after route mounting, so it resolves
+ * through a getter filled in once construction finishes (503 until then).
+ */
+export declare function createPiSubagentReportRouteHandler(getAgentManager: () => AgentManager | null): express.RequestHandler;
 export declare function createTerminalActivityRouteHandler(terminalManager: TerminalManager): express.RequestHandler;
 export type DaemonLifecycleIntent = {
     type: "shutdown";

package/node_modules/@bytetrue/server/dist/server/server/bootstrap.js

@@ -175,6 +175,13 @@ function resolveAgentMcpClientHost(host) {
     }
     return host;
 }
+function createLocalApiBaseUrl(listenTarget) {
+    if (!listenTarget || listenTarget.type !== "tcp") {
+        return null;
+    }
+    const host = resolveAgentMcpClientHost(listenTarget.host);
+    return `http://${formatHostForHttpUrl(host)}:${listenTarget.port}`;
+}
 function createAgentMcpBaseUrl(listenTarget) {
     if (!listenTarget || listenTarget.type !== "tcp") {
         return null;
@@ -203,6 +210,40 @@ const LOOPBACK_REMOTE_ADDRESSES = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1
 function isLoopbackRemoteAddress(remoteAddress) {
     return remoteAddress !== undefined && LOOPBACK_REMOTE_ADDRESSES.has(remoteAddress);
 }
+const PiSubagentReportSchema = z.object({
+    token: z.string().min(1),
+    observations: z.array(z.record(z.string(), z.unknown())).min(1),
+});
+/**
+ * Local, token-gated snapshots reported by the BySpace-installed subagent extension;
+ * deliberately skips daemon auth. The manager is created after route mounting, so it resolves
+ * through a getter filled in once construction finishes (503 until then).
+ */
+export function createPiSubagentReportRouteHandler(getAgentManager) {
+    return async (req, res) => {
+        const agentManager = getAgentManager();
+        if (!agentManager) {
+            res.status(503).json({ error: "Daemon is still starting" });
+            return;
+        }
+        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        const parsed = PiSubagentReportSchema.safeParse(req.body);
+        if (!parsed.success) {
+            res.status(400).json({ error: "Invalid subagent report" });
+            return;
+        }
+        const { token, observations } = parsed.data;
+        const outcome = agentManager.applyPiSubagentReport(token, observations);
+        if (outcome === "unauthorized") {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        res.status(204).end();
+    };
+}
 export function createTerminalActivityRouteHandler(terminalManager) {
     return async (req, res) => {
         if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
@@ -520,6 +561,12 @@ export async function createBySpaceDaemon(config, rootLogger, dependencies = {})
     });
     // Local, harmless, and token-gated; deliberately skips daemon auth.
     app.post("/api/terminal-activity", express.json(), createTerminalActivityRouteHandler(terminalManager));
+    // Subagent progress snapshots reported by the BySpace-installed subagent extension. Local,
+    // token-gated per agent launch; deliberately skips daemon auth. The route must mount before
+    // the bearer middleware below, but the manager is created later in this function, so it
+    // resolves through a holder filled in right after construction.
+    let piSubagentReportAgentManager = null;
+    app.post("/api/subagent-report", express.json(), createPiSubagentReportRouteHandler(() => piSubagentReportAgentManager));
     // Serve the bundled browser web UI when enabled. Mounted after service-proxy
     // classification and host/CORS handling, but before daemon bearer auth, so
     // static app files load without the daemon password while API/WebSocket calls
@@ -667,6 +714,7 @@ export async function createBySpaceDaemon(config, rootLogger, dependencies = {})
         resolveBySpaceToolPolicy: (provider) => resolveBySpaceToolPolicy(provider, daemonConfigStore.get().providers),
         logger,
     });
+    piSubagentReportAgentManager = agentManager;
     const detachAgentStoragePersistence = attachAgentStoragePersistence(logger, agentManager, agentStorage);
     await agentStorage.initialize();
     logger.info({ elapsed: elapsed() }, "Agent storage initialized");
@@ -1155,6 +1203,7 @@ export async function createBySpaceDaemon(config, rootLogger, dependencies = {})
                         agentMcpBaseUrl =
                             !mcpEnabled || config.mcpInjectIntoAgents === false ? null : mcpBaseUrl;
                         agentManager.setMcpBaseUrl(agentMcpBaseUrl);
+                        agentManager.setPiSubagentReportBaseUrl(createLocalApiBaseUrl(boundListenTarget));
                         agentManager.setBySpaceToolsEnabled(mcpEnabled && config.mcpInjectIntoAgents !== false);
                         daemonConfigStore.onFieldChange("mcp.enabled", (value) => {
                             mcpEnabled = value !== false;