@agentrific/server 0.1.6 → 0.3.0

package/index.js

@@ -465,6 +465,11 @@ var SessionSchema = z2.object({
   gitFlow: GitFlowSchema.optional(),
   gitDelivery: GitDeliverySchema.optional(),
   preparation: RunPreparationSchema.optional(),
+  usage: z2.object({
+    tokens: z2.number().nonnegative(),
+    turns: z2.number().int().nonnegative(),
+    tools: z2.number().int().nonnegative()
+  }).optional(),
   createdAt: z2.string().datetime(),
   updatedAt: z2.string().datetime()
 });
@@ -492,11 +497,18 @@ var CreateSessionSchema = z2.object({
 var SendMessageSchema = z2.object({
   message: z2.string().trim().max(2e4),
   attachmentIds: AttachmentIdsSchema.optional(),
-  clientMessageId: z2.string().min(1).max(120).optional()
+  clientMessageId: z2.string().min(1).max(120).optional(),
+  mode: z2.enum(["followUp", "steer"]).optional()
 }).refine(
   (input) => input.message.length > 0 || (input.attachmentIds?.length ?? 0) > 0,
   "Write a message or attach a file."
 );
+var FileChangeSchema = z2.object({
+  path: z2.string(),
+  patch: z2.string().optional(),
+  content: z2.string().optional(),
+  omitted: z2.boolean().optional()
+});
 var SessionEventSchema = z2.discriminatedUnion("type", [
   z2.object({ type: z2.literal("session.updated"), session: SessionSchema }),
   z2.object({
@@ -521,6 +533,7 @@ var SessionEventSchema = z2.discriminatedUnion("type", [
   }),
   z2.object({
     type: z2.literal("message.completed"),
+    tokens: z2.number().nonnegative().optional(),
     model: ModelIdentitySchema.optional(),
     sessionId: z2.string(),
     messageId: z2.string().optional(),
@@ -531,7 +544,8 @@ var SessionEventSchema = z2.discriminatedUnion("type", [
     sessionId: z2.string(),
     toolCallId: z2.string().optional(),
     tool: z2.string(),
-    input: z2.string()
+    input: z2.string(),
+    filePath: z2.string().optional()
   }),
   z2.object({
     type: z2.literal("tool.completed"),
@@ -539,6 +553,7 @@ var SessionEventSchema = z2.discriminatedUnion("type", [
     toolCallId: z2.string().optional(),
     tool: z2.string(),
     output: z2.string(),
+    fileChange: FileChangeSchema.optional(),
     isError: z2.boolean().default(false)
   }),
   z2.object({
@@ -1081,7 +1096,7 @@ async function startControl(directory, security2, status, maintenance2) {
 // package.json
 var package_default = {
   name: "@agentrific/server",
-  version: "0.1.6",
+  version: "0.3.0",
   description: "Self-hosted control plane for long-running coding agents",
   keywords: [
     "agentrific",
@@ -1118,6 +1133,7 @@ var package_default = {
     "@fastify/cors": "^11.3.0",
     "@fastify/multipart": "^10.1.2",
     "@inquirer/select": "^5.2.5",
+    diff: "^9.0.0",
     effect: "4.0.0-rc.117",
     fastify: "^5.6.2",
     "pino-pretty": "^13.1.3",
@@ -1467,7 +1483,7 @@ var UpdateDiscovery = class {
 
 // src/index.ts
 import { Effect as Effect16, ManagedRuntime } from "effect";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/automation.ts
 import { Effect as Effect7 } from "effect";
@@ -1773,13 +1789,29 @@ var AgentController = class {
       const entry = {
         session,
         agent,
-        unsubscribe: agent.subscribe(this.emit),
+        unsubscribe: () => {
+        },
         running: false,
         stopping: false,
         pending: []
       };
+      entry.unsubscribe = agent.subscribe((event) => {
+        this.emit(event);
+        if (event.type !== "message.completed" && event.type !== "tool.started") return;
+        const usage = entry.session.usage ?? { tokens: 0, turns: 0, tools: 0 };
+        entry.session = {
+          ...entry.session,
+          usage: {
+            tokens: usage.tokens + (event.type === "message.completed" ? event.tokens ?? 0 : 0),
+            turns: usage.turns + (event.type === "message.completed" ? 1 : 0),
+            tools: usage.tools + (event.type === "tool.started" ? 1 : 0)
+          },
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.emit({ type: "session.updated", session: entry.session });
+      });
       if (agent.model) {
-        entry.session = { ...session, model: agent.model };
+        entry.session = { ...entry.session, model: agent.model };
         this.emit({ type: "session.updated", session: entry.session });
       }
       this.active.set(session.id, entry);
@@ -1829,7 +1861,7 @@ var AgentController = class {
       Effect8.ensuring(Effect8.sync(() => this.working.delete(entry.session.id)))
     );
   }
-  send(session, message, attachments2 = [], messageId = randomUUID4()) {
+  send(session, message, attachments2 = [], messageId = randomUUID4(), mode = "followUp") {
     return this.lock(session.id).withPermit(
       Effect8.gen({ self: this }, function* () {
         if (this.closed)
@@ -1839,6 +1871,16 @@ var AgentController = class {
         if (this.hasMessage(session.id, messageId)) return;
         const entry = yield* this.open(session);
         yield* this.operation(async () => entry.agent.validateAttachments?.(attachments2));
+        const steering = entry.running && mode === "steer";
+        if (steering) {
+          if (!entry.agent.steer)
+            return yield* Effect8.fail(
+              new AgentError({ message: "This agent does not support steering." })
+            );
+          yield* this.operation(
+            () => entry.agent.steer(gitFlowPrompt(entry.session, message), attachments2)
+          );
+        }
         this.emit({
           type: "message.user",
           sessionId: session.id,
@@ -1846,6 +1888,7 @@ var AgentController = class {
           text: message,
           attachments: attachments2
         });
+        if (steering) return;
         if (entry.running) {
           entry.pending.push({ text: message, attachments: attachments2 });
           return;
@@ -2749,7 +2792,7 @@ import {
   createAgentSession as createAgentSession2,
   SessionManager as SessionManager2
 } from "@earendil-works/pi-coding-agent";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/delivery-tool.ts
 import { defineTool } from "@earendil-works/pi-coding-agent";
@@ -2783,9 +2826,70 @@ function deliveryTool(sessionId, delivery2) {
   });
 }
 
+// src/file-change.ts
+import { createWriteToolDefinition, defineTool as defineTool2 } from "@earendil-works/pi-coding-agent";
+import { createTwoFilesPatch } from "diff";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { z as z12 } from "zod";
+var previewLimit = 256e3;
+function boundFileChange(change) {
+  if ((change.patch?.length ?? 0) + (change.content?.length ?? 0) > previewLimit)
+    return { path: change.path, omitted: true };
+  return change;
+}
+var EditResultSchema = z12.object({
+  details: z12.object({ patch: z12.string().optional(), fileChange: FileChangeSchema.optional() }).optional()
+});
+function completedFileChange(result, path10) {
+  const parsed = EditResultSchema.safeParse(result);
+  if (!parsed.success) return;
+  const details = parsed.data.details;
+  if (details?.fileChange) return boundFileChange(details.fileChange);
+  if (path10 && details?.patch) return boundFileChange({ path: path10, patch: details.patch });
+}
+function fileWriteTool(cwd) {
+  const base = createWriteToolDefinition(cwd);
+  return defineTool2({
+    name: base.name,
+    label: base.label,
+    description: base.description,
+    promptSnippet: base.promptSnippet,
+    promptGuidelines: base.promptGuidelines,
+    parameters: base.parameters,
+    constrainedSampling: base.constrainedSampling,
+    async execute(toolCallId, args, signal, _onUpdate, ctx) {
+      let fileChange;
+      const tool = createWriteToolDefinition(cwd, {
+        operations: {
+          mkdir: async (dir) => {
+            await mkdir4(dir, { recursive: true });
+          },
+          // Pi invokes this inside its per-file mutation queue, so the snapshot
+          // and write cannot race another built-in edit/write on the same file.
+          writeFile: async (path10, content) => {
+            const previous = await readFile4(path10, "utf8").catch((error) => {
+              if (error.code === "ENOENT") return void 0;
+              throw error;
+            });
+            await writeFile2(path10, content, "utf8");
+            fileChange = boundFileChange(
+              previous === void 0 ? { path: args.path, content } : {
+                path: args.path,
+                patch: createTwoFilesPatch(args.path, args.path, previous, content)
+              }
+            );
+          }
+        }
+      });
+      const result = await tool.execute(toolCallId, args, signal, void 0, ctx);
+      return { ...result, details: { fileChange } };
+    }
+  });
+}
+
 // src/pi.ts
-var ToolResultSchema = z12.object({
-  content: z12.array(z12.object({ type: z12.string(), text: z12.string().optional() })).optional()
+var ToolResultSchema = z13.object({
+  content: z13.array(z13.object({ type: z13.string(), text: z13.string().optional() })).optional()
 }).passthrough();
 var boundedJson = (value, limit) => {
   let text;
@@ -2810,7 +2914,10 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
         model,
         modelRuntime: models2.runtime,
         sessionManager: SessionManager2.continueRecent(cwd, sessionDirectory),
-        customTools: run?.gitFlow && delivery2 ? [deliveryTool(sessionId, delivery2)] : []
+        customTools: [
+          fileWriteTool(cwd),
+          ...run?.gitFlow && delivery2 ? [deliveryTool(sessionId, delivery2)] : []
+        ]
       });
       return {
         get model() {
@@ -2834,6 +2941,12 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
             throw new Error(last.errorMessage ?? "The model request failed");
           }
         },
+        async steer(message, attachments2 = []) {
+          const context = await Effect12.runPromise(files.prepare(attachments2));
+          if (!session.isStreaming)
+            throw new Error("The response has finished. Send this message as a follow-up instead.");
+          await session.steer(message + context.context, context.images);
+        },
         async abort() {
           session.clearQueue();
           await session.abort();
@@ -2890,6 +3003,7 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
                   sessionId,
                   messageId: assistantMessageId,
                   text,
+                  tokens: event.message.usage.totalTokens,
                   model: models2.identity(event.message.provider, event.message.model)
                 });
               assistantMessageId = void 0;
@@ -2898,16 +3012,24 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
             }
             return false;
           }
+          const filePaths = /* @__PURE__ */ new Map();
+          const FileArgsSchema = z13.object({ path: z13.string() });
           function handleTool(event) {
             if (event.type === "tool_execution_start") {
               flushText();
               setActivity("thinking");
+              if (event.toolName === "edit" || event.toolName === "write") {
+                const args = FileArgsSchema.safeParse(event.args);
+                if (args.success) filePaths.set(event.toolCallId, args.data.path);
+              }
               emit({
                 type: "tool.started",
                 sessionId,
                 toolCallId: event.toolCallId,
                 tool: event.toolName,
-                input: boundedJson(event.args, 1200)
+                // Preserve complete Bash arguments so multiline commands can be inspected.
+                input: event.toolName === "bash" ? JSON.stringify(event.args) : boundedJson(event.args, 1200),
+                filePath: filePaths.get(event.toolCallId)
               });
               return true;
             }
@@ -2919,8 +3041,10 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
                 toolCallId: event.toolCallId,
                 tool: event.toolName,
                 output: toolOutput(event.result),
+                fileChange: event.isError ? void 0 : completedFileChange(event.result, filePaths.get(event.toolCallId)),
                 isError: event.isError
               });
+              filePaths.delete(event.toolCallId);
               setActivity("thinking");
               return true;
             }
@@ -2949,9 +3073,9 @@ function createPiFactory(files, models2, delivery2, createSession = createAgentS
 }
 
 // src/projects.ts
-import { access, readdir as readdir2, realpath, stat as stat2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { access, readdir as readdir2, realpath, stat as stat2, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 import { constants } from "node:fs";
 import { homedir } from "node:os";
 import path6 from "node:path";
@@ -2983,12 +3107,12 @@ function projectLock(store2) {
   }
   return lock;
 }
-var ProjectId = z13.string().trim().min(1).max(255);
+var ProjectId = z14.string().trim().min(1).max(255);
 async function gitDirectory(directory) {
   const location = path6.join(directory, ".git");
   const info = await stat2(location);
   if (info.isDirectory()) return location;
-  const contents = await readFile4(location, "utf8");
+  const contents = await readFile5(location, "utf8");
   const match = /^gitdir: (.+)\s*$/m.exec(contents);
   if (!match) throw new Error("Invalid Git worktree metadata.");
   const resolved = await realpath(path6.resolve(directory, match[1].trim()));
@@ -2998,21 +3122,21 @@ async function gitDirectory(directory) {
 async function identity(directory, preferred) {
   const filename = path6.join(await gitDirectory(directory), "agentrific-project-id");
   try {
-    return ProjectId.parse(await readFile4(filename, "utf8"));
+    return ProjectId.parse(await readFile5(filename, "utf8"));
   } catch (error) {
-    if (!z13.object({ code: z13.literal("ENOENT") }).safeParse(error).success) throw error;
+    if (!z14.object({ code: z14.literal("ENOENT") }).safeParse(error).success) throw error;
     const legacyFilename = path6.join(await gitDirectory(directory), "chatplans-project-id");
-    const legacy = await readFile4(legacyFilename, "utf8").catch((cause) => {
-      if (!z13.object({ code: z13.literal("ENOENT") }).safeParse(cause).success) throw cause;
+    const legacy = await readFile5(legacyFilename, "utf8").catch((cause) => {
+      if (!z14.object({ code: z14.literal("ENOENT") }).safeParse(cause).success) throw cause;
       return null;
     });
     const id = legacy === null ? preferred ?? randomUUID6() : ProjectId.parse(legacy);
     try {
-      await writeFile2(filename, id + "\n", { flag: "wx" });
+      await writeFile3(filename, id + "\n", { flag: "wx" });
       return id;
     } catch (writeError) {
-      if (!z13.object({ code: z13.literal("EEXIST") }).safeParse(writeError).success) throw writeError;
-      return ProjectId.parse(await readFile4(filename, "utf8"));
+      if (!z14.object({ code: z14.literal("EEXIST") }).safeParse(writeError).success) throw writeError;
+      return ProjectId.parse(await readFile5(filename, "utf8"));
     }
   }
 }
@@ -3032,7 +3156,7 @@ function scanProjects(root, store2) {
         let existing = registered.find((project2) => project2.id === id);
         if (found.some((project2) => project2.id === id) || existing && existing.path !== directory && await stat2(path6.join(existing.path, ".git")).catch(() => null)) {
           id = randomUUID6();
-          await writeFile2(
+          await writeFile3(
             path6.join(await gitDirectory(directory), "agentrific-project-id"),
             id + "\n"
           );
@@ -3071,11 +3195,11 @@ function reconnectProject(root, id, input, store2) {
       const filename = path6.join(await gitDirectory(directory), "agentrific-project-id");
       const replacedId = await identity(directory);
       const project = { id, name: path6.basename(directory), path: directory, available: true };
-      await writeFile2(filename, id + "\n");
+      await writeFile3(filename, id + "\n");
       try {
         await Effect13.runPromise(store2.relocateProject(project, previous.path, replacedId));
       } catch (error) {
-        await writeFile2(filename, replacedId + "\n");
+        await writeFile3(filename, replacedId + "\n");
         throw error;
       }
       return project;
@@ -3089,32 +3213,32 @@ import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "n
 import path7 from "node:path";
 
 // src/push-schema.ts
-import { z as z14 } from "zod";
-var PushBindingSchema = z14.object({
-  bindingId: z14.string().uuid(),
-  installationId: z14.string().uuid(),
-  deviceId: z14.string().uuid()
+import { z as z15 } from "zod";
+var PushBindingSchema = z15.object({
+  bindingId: z15.string().uuid(),
+  installationId: z15.string().uuid(),
+  deviceId: z15.string().uuid()
 });
-var PushStateSchema = z14.object({
-  bindings: z14.array(PushBindingSchema).max(10),
-  error: z14.string().nullable()
+var PushStateSchema = z15.object({
+  bindings: z15.array(PushBindingSchema).max(10),
+  error: z15.string().nullable()
 });
 var PendingPushSchema = PushEventSchema.extend({
-  remaining: z14.array(PushBindingSchema),
-  createdAt: z14.number(),
-  attempts: z14.number().int().nonnegative(),
-  nextAt: z14.number()
+  remaining: z15.array(PushBindingSchema),
+  createdAt: z15.number(),
+  attempts: z15.number().int().nonnegative(),
+  nextAt: z15.number()
 });
 
 // src/store.ts
 import { DatabaseSync } from "node:sqlite";
 import { Context as Context3, Data as Data3, Effect as Effect14, Layer as Layer3 } from "effect";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { randomUUID as randomUUID7 } from "node:crypto";
 var StorageError = class extends Data3.TaggedError("StorageError") {
 };
-var PayloadRow = z15.object({ payload: z15.string() });
-var EventRow = z15.object({ sequence: z15.number(), recorded_at: z15.string(), payload: z15.string() });
+var PayloadRow = z16.object({ payload: z16.string() });
+var EventRow = z16.object({ sequence: z16.number(), recorded_at: z16.string(), payload: z16.string() });
 var SqliteSessionStore = class {
   constructor(db) {
     this.db = db;
@@ -3165,7 +3289,7 @@ var SqliteSessionStore = class {
       const row = PayloadRow.parse(
         this.db.prepare("SELECT payload FROM settings WHERE id = 'server-id'").get()
       );
-      return z15.string().uuid().parse(JSON.parse(row.payload));
+      return z16.string().uuid().parse(JSON.parse(row.payload));
     });
   }
   saveDevice(device, tokenHash) {
@@ -3253,7 +3377,7 @@ var SqliteSessionStore = class {
       `).all();
       const insert = this.db.prepare("INSERT OR IGNORE INTO projects(id, payload) VALUES (?, ?)");
       for (const row of legacy) {
-        const id = z15.object({ id: z15.string() }).parse(row).id;
+        const id = z16.object({ id: z16.string() }).parse(row).id;
         insert.run(
           id,
           JSON.stringify({ id, name: id, path: path7.join(root, id), available: false })
@@ -3463,7 +3587,7 @@ var SqliteSessionStore = class {
         if (event.type === "message.user") this.claimAttachments(event.attachments ?? []);
         const result = this.db.prepare("INSERT INTO events(session_id, recorded_at, payload) VALUES (?, ?, ?)").run(sessionId, recordedAt, JSON.stringify(event));
         if (notification) {
-          const count = z15.object({ total: z15.number() }).parse(this.db.prepare("SELECT COUNT(*) AS total FROM push_outbox").get());
+          const count = z16.object({ total: z16.number() }).parse(this.db.prepare("SELECT COUNT(*) AS total FROM push_outbox").get());
           if (count.total >= 1e3)
             this.db.prepare(
               "DELETE FROM push_outbox WHERE rowid IN (SELECT rowid FROM push_outbox ORDER BY rowid LIMIT 1)"
@@ -3515,7 +3639,7 @@ var SessionStore = class extends Context3.Service()(
             for (const suffix of ["-wal", "-shm"])
               if (existsSync2(filename + suffix)) chmodSync(filename + suffix, 384);
             try {
-              const schema = z15.object({ user_version: z15.number() }).parse(db.prepare("PRAGMA user_version").get());
+              const schema = z16.object({ user_version: z16.number() }).parse(db.prepare("PRAGMA user_version").get());
               if (schema.user_version > 1)
                 throw new Error("This database requires a newer Agentrific server.");
               db.exec(`
@@ -3905,7 +4029,7 @@ app.get("/api/projects/:id", async (request, reply) => {
   return project ?? reply.code(404).send({ error: "Project not found on this server." });
 });
 app.post("/api/projects/:id/reconnect", async (request, reply) => {
-  const parsed = z16.object({ path: z16.string().trim().min(1).max(4096) }).safeParse(request.body);
+  const parsed = z17.object({ path: z17.string().trim().min(1).max(4096) }).safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: "Enter the project's new folder path." });
   const root = await Effect16.runPromise(store.projectsRoot(defaultProjectsRoot));
@@ -4037,9 +4161,9 @@ app.post(
     }
   })
 );
-var HistoryQuery = z16.object({
-  after: z16.coerce.number().int().nonnegative().default(0),
-  limit: z16.coerce.number().int().min(1).max(1e3).default(500)
+var HistoryQuery = z17.object({
+  after: z17.coerce.number().int().nonnegative().default(0),
+  limit: z17.coerce.number().int().min(1).max(1e3).default(500)
 });
 app.get("/api/sessions/:id/events", async (request, reply) => {
   const query = HistoryQuery.safeParse(request.query);
@@ -4133,6 +4257,7 @@ async function createAndStartSession(input) {
     status: "starting",
     agent: input.agent,
     model: selectedModel,
+    usage: { tokens: 0, turns: 0, tools: 0 },
     gitFlow: input.gitFlow,
     branch: null,
     createdAt: now,
@@ -4181,7 +4306,7 @@ app.post("/api/sessions", async (request, reply) => {
   if (!result.session) return reply.code(result.status).send({ error: result.error });
   return reply.code(201).send(result.session);
 });
-var StartTaskBody = z16.object({ prompt: z16.string().trim().max(2e4).optional() }).default({});
+var StartTaskBody = z17.object({ prompt: z17.string().trim().max(2e4).optional() }).default({});
 function startTask(id, instructionsOverride, automated = false) {
   return withTaskLock(
     "agent-dispatch",
@@ -4259,7 +4384,7 @@ app.patch("/api/automation", async (request, reply) => {
   return automation.configure(parsed.data);
 });
 app.patch("/api/automation/queue", async (request, reply) => {
-  const parsed = z16.object({ taskId: z16.string().min(1), beforeId: z16.string().min(1).nullable() }).safeParse(request.body);
+  const parsed = z17.object({ taskId: z17.string().min(1), beforeId: z17.string().min(1).nullable() }).safeParse(request.body);
   if (!parsed.success)
     return reply.code(400).send({ error: "Choose a task and a queue position." });
   try {
@@ -4289,7 +4414,13 @@ app.post(
         attachments.resolve(session.projectId, parsed.data.attachmentIds ?? [])
       );
       await Effect16.runPromise(
-        runtime.send(session, parsed.data.message, files, parsed.data.clientMessageId)
+        runtime.send(
+          session,
+          parsed.data.message,
+          files,
+          parsed.data.clientMessageId,
+          parsed.data.mode
+        )
       );
       return reply.code(202).send({ accepted: true });
     } catch (error) {