@akira-tl/forgerelay 0.5.1 → 0.5.4

package/dist/activity/query-service.js

@@ -0,0 +1,247 @@
+export class ActivityQueryService {
+    turns;
+    audit;
+    outputs;
+    constructor(turns, audit, outputs) {
+        this.turns = turns;
+        this.audit = audit;
+        this.outputs = outputs;
+    }
+    beginTurn(conversationScopeId) {
+        const turn = this.turns.begin(conversationScopeId);
+        return this.snapshot(turn.turnId);
+    }
+    currentTurnId(conversationScopeId) {
+        return this.turns.current(conversationScopeId)?.turnId;
+    }
+    snapshot(turnId, knownRevision) {
+        this.requireTurn(turnId);
+        const revision = this.audit.turnRevision(turnId);
+        const activities = this.audit.listActivitiesByTurn(turnId).map(toSummary);
+        const state = aggregateState(activities);
+        const changed = knownRevision === undefined || knownRevision !== revision;
+        return {
+            turnId,
+            revision,
+            changed,
+            state,
+            activities: changed ? activities : [],
+        };
+    }
+    detail(turnId, activityId) {
+        this.requireTurn(turnId);
+        const record = this.audit.getActivity(activityId);
+        if (!record || record.turnId !== turnId) {
+            throw new Error(`Unknown Activity ${activityId} in Host Turn ${turnId}.`);
+        }
+        const activity = toSummary(record);
+        if (!activity.detailAvailable) {
+            throw new Error(`Activity ${activityId} is summary-complete and has no lazy detail.`);
+        }
+        return {
+            activity,
+            ...(record.request !== undefined ? { request: record.request } : {}),
+            ...(record.result !== undefined ? { result: record.result } : {}),
+            ...(record.error !== undefined ? { error: record.error } : {}),
+        };
+    }
+    bashOutput(turnId, outputId) {
+        this.requireTurn(turnId);
+        const output = this.outputs.read(outputId);
+        if (!output)
+            throw new Error(`Unknown Bash output: ${outputId}.`);
+        const activities = this.audit.listActivitiesByTurn(turnId);
+        const visible = activities.some((activity) => activity.activityId === output.activityId || activityOutputId(activity) === outputId);
+        if (!visible) {
+            throw new Error(`Bash output ${outputId} is not part of Host Turn ${turnId}.`);
+        }
+        return {
+            outputId: output.outputId,
+            activityId: output.activityId,
+            processId: output.processId,
+            command: output.command,
+            output: output.output,
+            status: output.status,
+            ...(output.exitCode !== undefined ? { exitCode: output.exitCode } : {}),
+            ...(output.signal !== undefined ? { signal: output.signal } : {}),
+            timedOut: output.timedOut,
+            startedAt: output.startedAt,
+            ...(output.finishedAt !== undefined ? { finishedAt: output.finishedAt } : {}),
+        };
+    }
+    requireTurn(turnId) {
+        if (!this.turns.get(turnId))
+            throw new Error(`Unknown Host Turn: ${turnId}.`);
+    }
+}
+function toSummary(record) {
+    const request = asRecord(record.request);
+    const result = asRecord(record.result);
+    const structured = asRecord(result?.structuredContent);
+    const directProcessId = numberField(result, "processId") ?? numberField(request, "processId");
+    const processId = numberField(structured, "processId") ?? directProcessId;
+    const outputId = stringField(structured, "outputId")
+        ?? stringField(result, "outputId")
+        ?? stringField(request, "outputId");
+    const command = stringField(request, "command") ?? stringField(request, "cmd");
+    const durationMs = numberField(structured, "wallTimeMs")
+        ?? numberField(result, "wallTimeMs")
+        ?? elapsedMs(record.startedAt, record.updatedAt, record.state);
+    const bashLike = record.tool === "bash" || record.tool === "exec_command" || record.tool === "bash_result";
+    return {
+        activityId: record.activityId,
+        tool: record.tool,
+        kind: activityKind(record.tool),
+        status: activityStatus(record.state),
+        state: record.state,
+        title: activityTitle(record.tool),
+        target: activityTarget(record, request, result, structured),
+        detailAvailable: record.tool !== "rename" && record.tool !== "delete",
+        ...(record.workspace.id ? { workspaceId: record.workspace.id } : {}),
+        ...(processId !== undefined ? { processId } : {}),
+        ...(outputId !== undefined ? { outputId } : {}),
+        ...(bashLike && command !== undefined ? { commandLength: command.length } : {}),
+        ...(bashLike ? { bashPhase: bashPhase(record.state) } : {}),
+        startedAt: record.startedAt,
+        ...(record.state !== "executing" ? { finishedAt: record.updatedAt } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
+    };
+}
+function activityKind(tool) {
+    if (tool === "read")
+        return "read";
+    if (tool === "write")
+        return "write";
+    if (tool === "edit" || tool === "apply_patch")
+        return "edit";
+    if (tool === "rename")
+        return "rename";
+    if (tool === "delete")
+        return "delete";
+    if (tool === "bash_result")
+        return "shell-result";
+    if (tool === "bash" || tool === "exec_command")
+        return "shell";
+    if (tool === "capability")
+        return "capability";
+    return "tool";
+}
+function activityTitle(tool) {
+    const titles = {
+        read: "Read",
+        write: "Write",
+        edit: "Edit",
+        apply_patch: "Edit",
+        rename: "Rename",
+        delete: "Delete",
+        bash: "Bash",
+        exec_command: "Command",
+        bash_result: "Bash result",
+        capability: "Capability",
+    };
+    return titles[tool] ?? tool;
+}
+function activityTarget(record, request, result, structured) {
+    if (record.tool === "bash" || record.tool === "exec_command")
+        return "Shell command";
+    if (record.tool === "bash_result") {
+        const processId = numberField(result, "processId") ?? numberField(request, "processId");
+        const exitCode = numberField(result, "exitCode");
+        const signal = stringField(result, "signal");
+        const timedOut = booleanField(result, "timedOut");
+        const outcome = timedOut
+            ? "timed out"
+            : signal
+                ? `signal ${signal}`
+                : exitCode !== undefined
+                    ? `exit ${exitCode}`
+                    : record.state === "failed"
+                        ? "failed"
+                        : "completed";
+        return `Process ${processId ?? "?"} · ${outcome}`;
+    }
+    if (record.tool === "capability") {
+        const name = stringField(request, "name") ?? "capability";
+        const action = stringField(request, "action") ?? "run";
+        return `${name} · ${action}`;
+    }
+    if (record.tool === "rename") {
+        const from = stringField(request, "path")
+            ?? stringField(request, "from")
+            ?? stringField(request, "source");
+        const to = stringField(request, "newPath")
+            ?? stringField(request, "to")
+            ?? stringField(request, "destination");
+        return [from, to].filter((value) => Boolean(value)).join(" → ") || "path";
+    }
+    const path = stringField(request, "path");
+    if (path)
+        return path;
+    if (record.tool === "apply_patch") {
+        const files = arrayField(structured, "files");
+        const first = asRecord(files?.[0]);
+        const firstPath = stringField(first, "path");
+        if (firstPath)
+            return files && files.length > 1 ? `${firstPath} +${files.length - 1}` : firstPath;
+    }
+    return record.tool;
+}
+function activityStatus(state) {
+    if (state === "executing")
+        return "working";
+    if (state === "failed" || state === "blocked")
+        return "error";
+    return "done";
+}
+function bashPhase(state) {
+    if (state === "executing")
+        return "executing";
+    if (state === "returned")
+        return "returned";
+    if (state === "failed" || state === "blocked")
+        return "error";
+    return "done";
+}
+function aggregateState(activities) {
+    if (activities.length === 0)
+        return "working";
+    if (activities.some((activity) => activity.status === "working"))
+        return "working";
+    if (activities.some((activity) => activity.status === "error"))
+        return "error";
+    return "done";
+}
+function activityOutputId(activity) {
+    const request = asRecord(activity.request);
+    const result = asRecord(activity.result);
+    const structured = asRecord(result?.structuredContent);
+    return stringField(request, "outputId")
+        ?? stringField(result, "outputId")
+        ?? stringField(structured, "outputId");
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringField(record, key) {
+    return typeof record?.[key] === "string" ? record[key] : undefined;
+}
+function numberField(record, key) {
+    return typeof record?.[key] === "number" ? record[key] : undefined;
+}
+function booleanField(record, key) {
+    return typeof record?.[key] === "boolean" ? record[key] : undefined;
+}
+function arrayField(record, key) {
+    return Array.isArray(record?.[key]) ? record[key] : undefined;
+}
+function elapsedMs(startedAt, updatedAt, state) {
+    if (state === "executing")
+        return undefined;
+    const start = Date.parse(startedAt);
+    const end = Date.parse(updatedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return undefined;
+    return Math.max(0, end - start);
+}

package/dist/db/migrations.js

@@ -39,6 +39,16 @@ const migrations = [
         name: "activity-audit",
         up: migrateActivityAudit,
     },
+    {
+        version: 9,
+        name: "bash-output-audit",
+        up: migrateBashOutputAudit,
+    },
+    {
+        version: 10,
+        name: "activity-host-turns",
+        up: migrateActivityHostTurns,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
@@ -248,6 +258,64 @@ function migrateActivityAudit(sqlite) {
       on activity_audit_events(created_at);
   `);
 }
+function migrateBashOutputAudit(sqlite) {
+    sqlite.exec(`
+    create table if not exists bash_output_streams (
+      id text primary key,
+      activity_id text not null,
+      turn_id text not null,
+      conversation_scope_id text,
+      process_id integer not null,
+      workspace_id text not null,
+      workspace_root text not null,
+      command text not null,
+      tty integer not null default 0,
+      status text not null default 'running',
+      exit_code integer,
+      signal text,
+      timed_out integer not null default 0,
+      error text,
+      returned integer not null default 0,
+      completion_claimed_at text,
+      started_at text not null,
+      finished_at text
+    );
+
+    create index if not exists bash_output_streams_activity_idx
+      on bash_output_streams(activity_id);
+
+    create index if not exists bash_output_streams_workspace_idx
+      on bash_output_streams(workspace_id, started_at);
+
+    create table if not exists bash_output_chunks (
+      output_id text not null,
+      sequence integer not null,
+      channel text not null,
+      data blob not null,
+      created_at text not null,
+      primary key (output_id, sequence),
+      foreign key (output_id) references bash_output_streams(id) on delete cascade
+    );
+
+    create index if not exists bash_output_chunks_output_idx
+      on bash_output_chunks(output_id, sequence);
+  `);
+}
+function migrateActivityHostTurns(sqlite) {
+    sqlite.exec(`
+    create table if not exists activity_host_turns (
+      turn_id text primary key,
+      conversation_scope_id text,
+      created_at text not null
+    );
+
+    create index if not exists activity_host_turns_conversation_idx
+      on activity_host_turns(conversation_scope_id, created_at desc);
+
+    create index if not exists activity_host_turns_created_idx
+      on activity_host_turns(created_at desc);
+  `);
+}
 function addColumnIfMissing(sqlite, table, column, definition) {
     const columns = sqlite.prepare(`pragma table_info(${table})`).all();
     if (columns.some((existingColumn) => existingColumn.name === column))

package/dist/db/schema.js

@@ -1,4 +1,4 @@
-import { index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+import { blob, index, integer, primaryKey, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
 export const workspaceSessions = sqliteTable("workspace_sessions", {
     id: text("id").primaryKey(),
     root: text("root").notNull(),
@@ -97,6 +97,49 @@ export const activityAuditEvents = sqliteTable("activity_audit_events", {
     index("activity_audit_events_turn_idx").on(table.turnId, table.createdAt),
     index("activity_audit_events_created_idx").on(table.createdAt),
 ]);
+export const activityHostTurns = sqliteTable("activity_host_turns", {
+    turnId: text("turn_id").primaryKey(),
+    conversationScopeId: text("conversation_scope_id"),
+    createdAt: text("created_at").notNull(),
+}, (table) => [
+    index("activity_host_turns_conversation_idx").on(table.conversationScopeId, table.createdAt),
+    index("activity_host_turns_created_idx").on(table.createdAt),
+]);
+export const bashOutputStreams = sqliteTable("bash_output_streams", {
+    id: text("id").primaryKey(),
+    activityId: text("activity_id").notNull(),
+    turnId: text("turn_id").notNull(),
+    conversationScopeId: text("conversation_scope_id"),
+    processId: integer("process_id").notNull(),
+    workspaceId: text("workspace_id").notNull(),
+    workspaceRoot: text("workspace_root").notNull(),
+    command: text("command").notNull(),
+    tty: integer("tty", { mode: "boolean" }).notNull().default(false),
+    status: text("status").notNull().default("running"),
+    exitCode: integer("exit_code"),
+    signal: text("signal"),
+    timedOut: integer("timed_out", { mode: "boolean" }).notNull().default(false),
+    error: text("error"),
+    returned: integer("returned", { mode: "boolean" }).notNull().default(false),
+    completionClaimedAt: text("completion_claimed_at"),
+    startedAt: text("started_at").notNull(),
+    finishedAt: text("finished_at"),
+}, (table) => [
+    index("bash_output_streams_activity_idx").on(table.activityId),
+    index("bash_output_streams_workspace_idx").on(table.workspaceId, table.startedAt),
+]);
+export const bashOutputChunks = sqliteTable("bash_output_chunks", {
+    outputId: text("output_id")
+        .notNull()
+        .references(() => bashOutputStreams.id, { onDelete: "cascade" }),
+    sequence: integer("sequence").notNull(),
+    channel: text("channel").notNull(),
+    data: blob("data", { mode: "buffer" }).notNull(),
+    createdAt: text("created_at").notNull(),
+}, (table) => [
+    primaryKey({ columns: [table.outputId, table.sequence] }),
+    index("bash_output_chunks_output_idx").on(table.outputId, table.sequence),
+]);
 export const localAgentSessions = sqliteTable("local_agent_sessions", {
     id: text("id").primaryKey(),
     workspaceId: text("workspace_id"),

package/dist/lsp/test-support/server-fixture.js

@@ -5,7 +5,10 @@ import { join } from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { ActivityAuditStore } from "../../activity/audit-store.js";
+import { BashOutputStore } from "../../activity/bash-output-store.js";
+import { HostTurnStore } from "../../activity/host-turn-store.js";
 import { ActivityLifecycle } from "../../activity/lifecycle.js";
+import { ActivityQueryService } from "../../activity/query-service.js";
 import { loadConfig } from "../../config.js";
 import { createReviewCheckpointManager } from "../../review-checkpoints.js";
 import { ProcessManager } from "../../process-sessions.js";
@@ -34,11 +37,16 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
     });
     const store = new SqliteWorkspaceStore(stateDir);
     const workspaces = new WorkspaceRegistry(config, store);
-    const processSessions = new ProcessManager();
     const auditStore = new ActivityAuditStore(stateDir);
-    const activityLifecycle = new ActivityLifecycle(auditStore);
+    const bashOutputStore = new BashOutputStore(stateDir);
+    const hostTurnStore = new HostTurnStore(stateDir);
+    const activityQueries = new ActivityQueryService(hostTurnStore, auditStore, bashOutputStore);
+    const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
+    const activityLifecycle = new ActivityLifecycle(auditStore, {
+        turnIdForConversation: (conversationScopeId) => activityQueries.currentTurnId(conversationScopeId),
+    });
     const codeIntelligence = new CodeIntelligenceManager(config, options.codeIntelligenceOptions);
-    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
     const client = new Client({ name: "forgerelay-code-intelligence-test-client", version: "1.0.0" });
     await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
@@ -51,6 +59,8 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         await server.close();
         await codeIntelligence.shutdown();
         processSessions.shutdown();
+        hostTurnStore.close();
+        bashOutputStore.close();
         auditStore.close();
         store.close();
     };

package/dist/process-sessions.js

@@ -209,6 +209,7 @@ export class ProcessManager {
     completedProcessTtlMs;
     maxStartYieldMs;
     monotonicNow;
+    outputAudit;
     nextProcessId = 1;
     constructor(options = {}) {
         this.maxBufferCharacters = options.maxBufferCharacters ?? DEFAULT_BUFFER_CHARACTERS;
@@ -225,6 +226,7 @@ export class ProcessManager {
             ?? COMPLETED_PROCESS_TTL_MS;
         this.maxStartYieldMs = options.maxStartYieldMs ?? MAX_START_YIELD_MS;
         this.monotonicNow = options.monotonicNow ?? (() => performance.now());
+        this.outputAudit = options.outputAudit;
     }
     async start(input) {
         input.signal?.throwIfAborted();
@@ -241,6 +243,10 @@ export class ProcessManager {
                 this.startPipe(processEntry, input);
         }
         catch (error) {
+            this.finishAudit(processEntry, {
+                timedOut: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
             this.processes.delete(processEntry.id);
             throw error;
         }
@@ -349,8 +355,14 @@ export class ProcessManager {
     shutdown() {
         for (const processEntry of this.processes.values()) {
             this.clearProcessTimers(processEntry);
-            if (processEntry.running)
+            if (processEntry.running) {
+                this.finishAudit(processEntry, {
+                    signal: "shutdown",
+                    timedOut: false,
+                    error: "ForgeRelay shut down while the process was still running.",
+                });
                 processEntry.process?.kill("SIGTERM");
+            }
         }
         this.processes.clear();
         this.completedByWorkspace.clear();
@@ -389,10 +401,25 @@ export class ProcessManager {
         const exitPromise = new Promise((resolve) => {
             resolveExit = resolve;
         });
+        const id = this.nextProcessId++;
+        const outputId = this.outputAudit && input.audit
+            ? this.outputAudit.begin({
+                activityId: input.audit.activityId,
+                turnId: input.audit.turnId,
+                ...(input.audit.conversationScopeId ? { conversationScopeId: input.audit.conversationScopeId } : {}),
+                processId: id,
+                workspaceId: input.workspaceId,
+                workspaceRoot: input.workspaceRoot ?? input.cwd,
+                command: input.command,
+                tty: input.tty === true,
+            })
+            : undefined;
         return {
-            id: this.nextProcessId++,
+            id,
             workspaceId: input.workspaceId,
             command: input.command,
+            ...(outputId ? { outputId } : {}),
+            auditFinished: false,
             startedAtMonotonic: this.monotonicNow(),
             columns: terminalSize(input.columns, DEFAULT_COLUMNS),
             rows: terminalSize(input.rows, DEFAULT_ROWS),
@@ -426,9 +453,9 @@ export class ProcessManager {
             kill: (signal = "SIGTERM") => terminateProcessTree(child, signal, detached),
             resize: input.tty ? () => undefined : undefined,
         };
-        child.stdout.on("data", (data) => this.append(processEntry, data.toString("utf8")));
-        child.stderr.on("data", (data) => this.append(processEntry, data.toString("utf8")));
-        child.on("error", (error) => this.append(processEntry, `${error.message}\n`));
+        child.stdout.on("data", (data) => this.append(processEntry, "stdout", data));
+        child.stderr.on("data", (data) => this.append(processEntry, "stderr", data));
+        child.on("error", (error) => this.append(processEntry, "process", `${error.message}\n`));
         child.on("close", (code, signal) => this.finish(processEntry, code ?? undefined, signal ?? undefined));
     }
     async startPty(processEntry, input) {
@@ -462,7 +489,7 @@ export class ProcessManager {
             kill: (signal) => pty.kill(signal),
             resize: (columns, rows) => pty.resize(columns, rows),
         };
-        pty.onData((data) => this.append(processEntry, data));
+        pty.onData((data) => this.append(processEntry, "pty", data));
         pty.onExit(({ exitCode, signal }) => {
             this.finish(processEntry, exitCode, signal === 0 ? undefined : String(signal));
         });
@@ -475,6 +502,11 @@ export class ProcessManager {
         processEntry.signal = signal;
         processEntry.finishedAtMonotonic = this.monotonicNow();
         processEntry.process = undefined;
+        this.finishAudit(processEntry, {
+            ...(exitCode !== undefined ? { exitCode } : {}),
+            ...(signal ? { signal } : {}),
+            timedOut: processEntry.timedOut,
+        });
         if (processEntry.executionTimeoutTimer)
             clearTimeout(processEntry.executionTimeoutTimer);
         if (processEntry.forceKillTimer)
@@ -512,8 +544,17 @@ export class ProcessManager {
         processEntry.cleanupTimer = setTimeout(() => this.removeProcess(processEntry.id), remainingMs);
         processEntry.cleanupTimer.unref();
     }
-    append(processEntry, output) {
-        processEntry.buffer.append(output);
+    append(processEntry, channel, output) {
+        if (processEntry.outputId && !processEntry.auditFinished) {
+            this.outputAudit?.append(processEntry.outputId, channel, output);
+        }
+        processEntry.buffer.append(typeof output === "string" ? output : Buffer.from(output).toString("utf8"));
+    }
+    finishAudit(processEntry, input) {
+        if (!processEntry.outputId || processEntry.auditFinished)
+            return;
+        processEntry.auditFinished = true;
+        this.outputAudit?.finish(processEntry.outputId, input);
     }
     consume(processEntry, maxOutputTokens) {
         const limit = boundedInteger(maxOutputTokens, DEFAULT_MAX_OUTPUT_TOKENS, 100_000);
@@ -526,6 +567,7 @@ export class ProcessManager {
         return {
             processId,
             sessionId: processId,
+            ...(processEntry.outputId ? { outputId: processEntry.outputId } : {}),
             output: buffered.output,
             outputTruncated: processEntry.outputWasTruncated,
             running: processEntry.running,