dsh-wsr-execution 0.2.1 → 0.2.2

package/src/intake/plugin.js

@@ -1,9 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
-import { readFile, readdir, realpath, stat, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { lstat, readFile, readdir, realpath, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 import { IntakeSessionBindingRepository } from "./binding-repository.js";
-import { parseWsrCommand } from "./command.js";
+import { parseWsrCommand, promptDiagnostic } from "./command.js";
 import {
   createDshSessionControlPlaneReadModel,
   registerDeliveryControlPlaneGateway,
@@ -61,6 +62,72 @@ function error(code) {
   return Object.freeze({ kind: "ERROR", code, message: code });
 }
 
+function gitInitFailure(cause) {
+  return Object.assign(new Error("GIT_INIT_FAILED", { cause }), { code: "GIT_INIT_FAILED" });
+}
+
+async function defaultGitInit(workspace) {
+  await runGit(workspace, ["init", "--quiet"]);
+}
+
+async function runGit(workspace, arguments_) {
+  return new Promise((accept, reject) => {
+    execFile("git", arguments_, { cwd: workspace }, (cause, stdout) => cause === null ? accept(stdout) : reject(cause));
+  });
+}
+
+async function hasGitHead(workspace) {
+  try {
+    await runGit(workspace, ["rev-parse", "--verify", "HEAD"]);
+    return true;
+  } catch (cause) {
+    if (cause?.code === 128) return false;
+    throw cause;
+  }
+}
+
+async function ensureGitHead(workspace) {
+  if (!await hasGitHead(workspace)) {
+    await runGit(workspace, ["add", "-A", "--", "."]);
+    await runGit(workspace, [
+      "-c", "user.name=WSR Workspace Initializer",
+      "-c", "user.email=wsr@localhost",
+      "-c", "commit.gpgSign=false",
+      "commit", "--quiet", "--allow-empty", "--no-verify", "-m", "Initialize WSR workspace",
+    ]);
+  }
+  await runGit(workspace, ["rev-parse", "--verify", "HEAD^{tree}"]);
+}
+
+async function hasGitMarker(workspace) {
+  try {
+    const marker = await lstat(path.join(workspace, ".git"));
+    return marker.isDirectory() || marker.isFile();
+  } catch (cause) {
+    if (cause?.code === "ENOENT") return false;
+    throw cause;
+  }
+}
+
+/** Establish the Git boundary only for an already authorized exact workspace. */
+export async function ensureGitWorktree(workspace, initialize = defaultGitInit) {
+  try {
+    if (typeof workspace !== "string" || !path.isAbsolute(workspace) || typeof initialize !== "function") {
+      throw new TypeError("workspace must be an absolute path");
+    }
+    const canonical = await realpath(workspace);
+    if (canonical !== workspace || !(await stat(canonical)).isDirectory()) throw new TypeError("workspace is not canonical");
+    const initialized = !await hasGitMarker(canonical);
+    if (initialized) await initialize(canonical);
+    if (!await hasGitMarker(canonical)) throw new TypeError("git marker was not created");
+    await ensureGitHead(canonical);
+    return Object.freeze({ path: canonical, initialized });
+  } catch (cause) {
+    if (cause?.code === "GIT_INIT_FAILED") throw cause;
+    throw gitInitFailure(cause);
+  }
+}
+
 function textOf(content) {
   if (!Array.isArray(content)) return "";
   return content.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text).join("");
@@ -143,7 +210,7 @@ export function presentToDshSession(agent, presentation, createId = () => `cmd-w
   const commandId = createId();
   agent.session.append("command/run", {
     commandId,
-    name: "wsr",
+    name: "wsr-presentation",
     source: { kind: "plugin", plugin: "workflow-execution" },
   });
   agent.session.append("command/done", { commandId, kind: presentation?.kind === "error" ? "error" : "success", text });
@@ -201,16 +268,36 @@ export async function createPluginRuntime(config, options = {}) {
   const factory = options.factory ?? new api.DefaultExecutionApplicationFactory();
   const application = await factory.create(admitted.configFile, dependencies);
   const control = options.control ?? api.getExecutionApplicationControl(application);
+  const ownerProjection = options.ownerProjection ?? api.getExecutionControlPlaneProjection(application);
   const bindingInventory = () => typeof control.bindingInventory === "function" ? control.bindingInventory() : control.list();
+  const archiveTerminal = async (sessionKey, correlation, deliveryId) => {
+    const snapshot = await ownerProjection.snapshot();
+    const matches = snapshot.deliveries.filter((delivery) => delivery.lifecycle === "TERMINAL"
+      && delivery.navigation?.sessionCorrelation === correlation
+      && (deliveryId === undefined || delivery.deliveryId === deliveryId));
+    if (matches.length !== 1) {
+      throw Object.assign(new Error("INTAKE_BINDING_INVARIANT_VIOLATION"), { code: "INTAKE_BINDING_INVARIANT_VIOLATION" });
+    }
+    await bindings.archiveTerminal(sessionKey, matches[0]);
+  };
   try {
     await application.start();
     const inventory = await bindingInventory();
     await bindings.start(inventory);
+    const snapshot = await ownerProjection.snapshot();
     for (const binding of await bindings.list()) {
       const sameDelivery = inventory.filter((item) => item.deliveryId === binding.deliveryId || item.worktree === binding.worktree);
       const matches = sameDelivery.filter((item) => item.deliveryId === binding.deliveryId && item.worktree === binding.worktree
         && item.deliveryBindingIdentity === binding.deliveryBindingIdentity);
       if (matches.length === 0 && sameDelivery.length === 0) {
+        const terminal = snapshot.deliveries.filter((delivery) => delivery.lifecycle === "TERMINAL"
+          && delivery.deliveryId === binding.deliveryId && delivery.worktree === binding.worktree
+          && delivery.deliveryBindingIdentity === binding.deliveryBindingIdentity
+          && delivery.navigation?.sessionCorrelation === binding.correlation);
+        if (terminal.length === 1) {
+          await bindings.archiveTerminal(binding.sessionKey, terminal[0]);
+          continue;
+        }
         await bindings.detach(binding.deliveryId);
         continue;
       }
@@ -258,6 +345,19 @@ export async function createPluginRuntime(config, options = {}) {
     return promise;
   }
 
+  async function awaitRegistrationOrResult(execution, correlation) {
+    const result = execution.then((value) => Object.freeze({ kind: "result", result: value }));
+    while (true) {
+      const first = await Promise.race([
+        result,
+        control.waitForDelivery(correlation, options.deliveryRegistrationTimeoutMs ?? 10_000)
+          .then((delivery) => Object.freeze({ kind: "delivery", delivery })),
+      ]);
+      if (first.kind === "result" || first.delivery !== undefined) return first;
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+
   async function invokeForSession(input) {
     if (!accepting) return error("APPLICATION_CLOSING");
     const candidateBinding = await bindings.bySession(input.sessionKey);
@@ -288,24 +388,19 @@ export async function createPluginRuntime(config, options = {}) {
       if (candidateBinding !== undefined) return error("SESSION_INTAKE_BOUND");
       const authorization = await conversationAuthorization();
       if (authorization === undefined) return error("DSH_INTAKE_WORKSPACE_UNAUTHORIZED");
+      try { await (options.ensureGitWorktree ?? ensureGitWorktree)(authorization.path); }
+      catch { return error("GIT_INIT_FAILED"); }
       sessionByCorrelation.set(correlation, input.sessionKey);
       const execution = track(service.invoke(Object.freeze({ operation: "create", selector: operation.selector, worktree: authorization.path, directive: operation.directive, turn, correlation }), authorization));
-      const first = await Promise.race([
-        execution.then((result) => Object.freeze({ kind: "result", result })),
-        control.waitForDelivery(correlation, options.deliveryRegistrationTimeoutMs ?? 10_000)
-          .then((delivery) => Object.freeze({ kind: "delivery", delivery })),
-      ]);
+      const first = await awaitRegistrationOrResult(execution, correlation);
       if (first.kind === "result") {
+        if (first.result.kind === "TERMINAL") await archiveTerminal(input.sessionKey, correlation, first.result.deliveryId);
         if (first.result.kind === "ERROR" || first.result.kind === "TERMINAL" || first.result.kind === "RECOVERY") sessionByCorrelation.delete(correlation);
         return first.result;
       }
       const delivery = first.delivery;
-      if (delivery === undefined) {
-        const result = await execution;
-        if (result.kind === "ERROR" || result.kind === "TERMINAL") sessionByCorrelation.delete(correlation);
-        return result;
-      }
       await bindings.claim(Object.freeze({ sessionKey: input.sessionKey, correlation, deliveryId: delivery.deliveryId, worktree: delivery.worktree, deliveryBindingIdentity: delivery.deliveryBindingIdentity }));
+      control.attach(delivery.deliveryId, correlation);
       void track(execution.then(async (result) => {
         try { await options.present?.(Object.freeze({
           sessionKey: input.sessionKey,
@@ -313,7 +408,8 @@ export async function createPluginRuntime(config, options = {}) {
         })); }
         catch { /* presentation is not Delivery control */ }
         if (result.kind === "TERMINAL" || result.kind === "ERROR") {
-          await bindings.detach(delivery.deliveryId);
+          if (result.kind === "TERMINAL") await archiveTerminal(input.sessionKey, correlation, delivery.deliveryId);
+          else await bindings.detach(delivery.deliveryId);
           sessionByCorrelation.delete(correlation);
         }
       })).catch(() => undefined);
@@ -339,6 +435,7 @@ export async function createPluginRuntime(config, options = {}) {
         const recovered = (await bindingInventory()).filter((item) => item.deliveryId === result.deliveryId && item.worktree === result.worktree);
         if (recovered.length !== 1) return error("INTAKE_BINDING_INVARIANT_VIOLATION");
         await bindings.claim(Object.freeze({ sessionKey: input.sessionKey, correlation, deliveryId: result.deliveryId, worktree: result.worktree, deliveryBindingIdentity: recovered[0].deliveryBindingIdentity }));
+        control.attach(result.deliveryId, correlation);
         sessionByCorrelation.set(correlation, input.sessionKey);
       }
       return result;
@@ -357,7 +454,7 @@ export async function createPluginRuntime(config, options = {}) {
     const result = await service.invoke(Object.freeze({ operation: "abandon", deliveryId: operation.deliveryId, correlation }));
     if (result.kind === "TERMINAL") {
       const detached = await bindings.byDelivery(operation.deliveryId);
-      await bindings.detach(operation.deliveryId);
+      if (detached !== undefined) await archiveTerminal(detached.sessionKey, detached.correlation, operation.deliveryId);
       if (detached !== undefined) sessionByCorrelation.delete(detached.correlation);
     }
     return result;
@@ -385,7 +482,7 @@ export async function createPluginRuntime(config, options = {}) {
     return closePromise;
   }
 
-  return Object.freeze({ application, service, control, bindings, invokeForSession, answerForSession, close });
+  return Object.freeze({ application, service, control, ownerProjection, bindings, invokeForSession, answerForSession, close });
 }
 
 function commandTurn(rawInput) {
@@ -394,7 +491,7 @@ function commandTurn(rawInput) {
 }
 
 export async function recordWsrCommandInput(agent, rawInput, attachments = [], createId = () => `message-workflow-execution-${randomUUID()}`) {
-  if (agent === null || typeof agent !== "object" || typeof agent.followup !== "function" || typeof agent.whenIdle !== "function"
+  if (agent === null || typeof agent !== "object" || typeof agent.session?.append !== "function"
     || typeof rawInput !== "string" || !Array.isArray(attachments) || typeof createId !== "function") {
     throw new TypeError("DSH_INTAKE_USER_INPUT_INVALID");
   }
@@ -407,8 +504,7 @@ export async function recordWsrCommandInput(agent, rawInput, attachments = [], c
       ...attachments,
     ]),
   });
-  agent.followup(message);
-  await agent.whenIdle();
+  agent.session.append("user/message", message, { surfaceOp: "append" });
   return message;
 }
 
@@ -430,11 +526,9 @@ export async function apply(ctx, config) {
   const runtime = await createPluginRuntime(config, { present: (value) => presentationRouter.present(value),
   sessionAvailable: (sessionKey) => ctx.agents.get(sessionKey) !== undefined,
   resolveConversationWorkspace: async (agent) => resolveConversationWorkspace(ctx, agent) });
-  const executionApi = await import("wsr-execution");
-  const ownerProjection = executionApi.getExecutionControlPlaneProjection(runtime.application);
   await registerDeliveryControlPlaneGateway(
     ctx,
-    createDshSessionControlPlaneReadModel(ownerProjection, runtime.bindings),
+    createDshSessionControlPlaneReadModel(runtime.ownerProjection, runtime.bindings),
   );
   const active = new Set();
   const attachmentStore = ctx.attachments;
@@ -446,39 +540,39 @@ export async function apply(ctx, config) {
     recordInput: true,
     async handler(invocation) {
       return run((async () => {
-        let query = false;
         try {
+          await recordWsrCommandInput(invocation.agent, invocation.rawInput, invocation.attachments);
           const operation = parseWsrCommand(invocation.rawInput);
-          if (["create", "recover"].includes(operation.operation)) {
-            presentationRouter.retain(String(invocation.agent.id), invocation.agent);
-          }
-          query = operation.operation === "list" || operation.operation === "status";
           const { createIntakePresentation, presentationForIntakeResult, serializeIntakePresentation } = await import("wsr-execution");
-          if (!query) {
-            await recordWsrCommandInput(invocation.agent, invocation.rawInput, invocation.attachments);
-            presentToDshSession(invocation.agent, createIntakePresentation(
-              String(invocation.commandId), "command-accepted", {},
-            ));
+          const complete = (presentation, kind) => {
+            presentToDshSession(invocation.agent, presentation);
+            return { kind, text: serializeIntakePresentation(presentation, 4096) };
+          };
+          const diagnostic = promptDiagnostic(operation, invocation.attachments);
+          if (diagnostic !== undefined) {
+            const presentation = createIntakePresentation(`presentation-${randomUUID()}`, "error", diagnostic);
+            return complete(presentation, "error");
           }
           if (invocation.attachments.length > 0 && !["create", "action-finish"].includes(operation.operation)) {
             const presentation = createIntakePresentation(
               `presentation-${randomUUID()}`, "error", { code: "WSR_COMMAND_INVALID", message: "WSR_COMMAND_INVALID" },
             );
-            if (!query) presentToDshSession(invocation.agent, presentation);
-            return { kind: "error", text: serializeIntakePresentation(presentation, 4096) };
+            return complete(presentation, "error");
+          }
+          if (["create", "recover"].includes(operation.operation)) {
+            presentationRouter.retain(String(invocation.agent.id), invocation.agent);
           }
           const result = await runtime.invokeForSession({ sessionKey: String(invocation.agent.id), agent: invocation.agent, operation, turnText: commandTurn(invocation.rawInput), images: invocation.attachments, attachmentStore, signal: invocation.signal });
           if (["create", "recover"].includes(operation.operation) && !["START_UNCERTAIN", "RECOVERY"].includes(result.kind)) {
             presentationRouter.release(String(invocation.agent.id));
           }
           const presentation = presentationForDshOperation({ createIntakePresentation, presentationForIntakeResult }, `presentation-${randomUUID()}`, operation, result, 4096);
-          if (!query) presentToDshSession(invocation.agent, presentation);
-          return { kind: result.kind === "ERROR" ? "error" : "success", text: serializeIntakePresentation(presentation, 4096) };
+          return complete(presentation, result.kind === "ERROR" ? "error" : "success");
         } catch (cause) {
           const { createIntakePresentation, serializeIntakePresentation } = await import("wsr-execution");
           const code = typeof cause?.code === "string" ? cause.code : "DSH_INTAKE_FAILED";
           const presentation = createIntakePresentation(`presentation-${randomUUID()}`, "error", { code, message: code });
-          if (!query) presentToDshSession(invocation.agent, presentation);
+          presentToDshSession(invocation.agent, presentation);
           return { kind: "error", text: serializeIntakePresentation(presentation, 4096) };
         }
       })());