@obrain/cli 0.1.11 → 0.1.12

package/dist/index.js

@@ -71573,6 +71573,7 @@ class OpenCodeA2AAgent {
   path;
   port;
   client;
+  runningTasks = new Map;
   server = null;
   constructor(path, port) {
     this.path = path;
@@ -71645,7 +71646,7 @@ class OpenCodeA2AAgent {
       version: "0.1.0",
       url: `${agentUrl}/a2a/jsonrpc`,
       skills: userSkills,
-      capabilities: { pushNotifications: false },
+      capabilities: { pushNotifications: false, streaming: true },
       defaultInputModes: ["text"],
       defaultOutputModes: ["text"],
       additionalInterfaces: [
@@ -71658,36 +71659,228 @@ class OpenCodeA2AAgent {
   }
   async execute(requestContext, eventBus) {
     const userMessage = requestContext.userMessage;
-    const session = await this.client.session.create();
-    const callerContext = this.getCallerContext(requestContext);
-    const executionContextText = this.buildExecutionContextText(requestContext);
-    const promptParts = userMessage.parts.filter((p) => p.kind === "text").map((part) => ({
-      type: "text",
-      text: part.text
-    }));
-    if (executionContextText) {
-      promptParts.unshift({
-        type: "text",
-        text: executionContextText
-      });
+    const task = requestContext.task ?? {
+      kind: "task",
+      id: requestContext.taskId,
+      contextId: requestContext.contextId,
+      status: {
+        state: "submitted",
+        timestamp: new Date().toISOString()
+      },
+      history: [userMessage],
+      metadata: userMessage.metadata
+    };
+    if (!requestContext.task) {
+      eventBus.publish(task);
     }
-    const result = await this.client.session.prompt({
-      ...callerContext.isOwnerCall ? {} : { agent: "plan" },
-      sessionID: session.data?.id,
-      parts: promptParts
+    this.runningTasks.set(requestContext.taskId, {
+      contextId: requestContext.contextId,
+      canceled: false,
+      finalized: false
     });
-    for (const part of result.data?.parts || []) {
-      if (part.type === "text") {
-        eventBus.publish({
+    this.runTask(requestContext, eventBus);
+  }
+  async runTask(requestContext, eventBus) {
+    const userMessage = requestContext.userMessage;
+    const publishStatus = (state, options) => eventBus.publish({
+      kind: "status-update",
+      taskId: requestContext.taskId,
+      contextId: requestContext.contextId,
+      status: {
+        state,
+        ...options?.message ? { message: options.message } : {},
+        timestamp: new Date().toISOString()
+      },
+      final: options?.final ?? false
+    });
+    const publishWorkingTask = () => publishStatus("working");
+    const runningTask = () => this.runningTasks.get(requestContext.taskId);
+    const isCanceled = () => runningTask()?.canceled === true;
+    const publishArtifact = (artifactId, name, text, options) => eventBus.publish({
+      kind: "artifact-update",
+      taskId: requestContext.taskId,
+      contextId: requestContext.contextId,
+      artifact: {
+        artifactId,
+        name,
+        parts: [{ kind: "text", text }]
+      },
+      append: options?.append,
+      lastChunk: options?.lastChunk
+    });
+    const stringifyEvent = (event) => {
+      try {
+        return JSON.stringify(event, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+      } catch (error51) {
+        logger.warn({ error: error51 }, "Failed to serialize OpenCode event");
+        return JSON.stringify({ type: "unserializable-event" });
+      }
+    };
+    try {
+      if (isCanceled()) {
+        return;
+      }
+      publishWorkingTask();
+      const session = await this.client.session.create();
+      const taskState = runningTask();
+      if (taskState) {
+        taskState.sessionId = session.data?.id;
+      }
+      if (isCanceled()) {
+        if (session.data?.id) {
+          await this.client.session.abort({ sessionID: session.data.id });
+        }
+        return;
+      }
+      const callerContext = this.getCallerContext(requestContext);
+      const executionContextText = this.buildExecutionContextText(requestContext);
+      const promptParts = userMessage.parts.filter((p) => p.kind === "text").map((part) => ({
+        type: "text",
+        text: part.text
+      }));
+      if (executionContextText) {
+        promptParts.unshift({
+          type: "text",
+          text: executionContextText
+        });
+      }
+      const events = await this.client.event.subscribe();
+      await this.client.session.promptAsync({
+        ...callerContext.isOwnerCall ? {} : { agent: "plan" },
+        sessionID: session.data?.id,
+        parts: promptParts
+      });
+      let assistantMessageID;
+      for await (const event of events.stream) {
+        if (isCanceled()) {
+          return;
+        }
+        if (event.type === "message.part.delta") {
+          continue;
+        }
+        publishArtifact("opencode-events", "OpenCode events", `${stringifyEvent(event)}
+`, { append: true });
+        publishWorkingTask();
+        if (event.type === "message.updated" && event.properties.info.sessionID === session.data?.id && event.properties.info.role === "assistant") {
+          assistantMessageID = event.properties.info.id;
+        }
+        if (event.type === "session.status" && event.properties.sessionID === session.data?.id && event.properties.status.type === "idle") {
+          break;
+        }
+      }
+      if (isCanceled()) {
+        return;
+      }
+      let responseMessage = null;
+      if (assistantMessageID) {
+        const result = await this.client.session.message({
+          sessionID: session.data?.id,
+          messageID: assistantMessageID
+        });
+        responseMessage = {
           kind: "message",
           messageId: v4_default(),
           role: "agent",
-          parts: [{ kind: "text", text: part.text }]
-        });
+          contextId: requestContext.contextId,
+          taskId: requestContext.taskId,
+          parts: result.data?.parts?.filter((part) => part.type === "text").map((part) => ({
+            kind: part.type,
+            text: part.text
+          })) || []
+        };
+      } else {
+        responseMessage = {
+          kind: "message",
+          messageId: v4_default(),
+          role: "agent",
+          contextId: requestContext.contextId,
+          taskId: requestContext.taskId,
+          parts: []
+        };
+      }
+      if (responseMessage.parts.length > 0) {
+        publishArtifact("opencode-response", "OpenCode response", responseMessage.parts.filter((part) => part.kind === "text").map((part) => part.text).join(`
+`), { lastChunk: true });
+      }
+      publishStatus("completed", {
+        message: responseMessage,
+        final: true
+      });
+      const completedTaskState = runningTask();
+      if (completedTaskState) {
+        completedTaskState.finalized = true;
+      }
+      eventBus.finished();
+    } catch (error51) {
+      if (isCanceled()) {
+        return;
+      }
+      logger.error({ error: error51 }, "OpenCode task failed");
+      publishStatus("failed", {
+        message: {
+          kind: "message",
+          messageId: v4_default(),
+          role: "agent",
+          contextId: requestContext.contextId,
+          taskId: requestContext.taskId,
+          parts: [
+            {
+              kind: "text",
+              text: "OpenCode task failed."
+            }
+          ]
+        },
+        final: true
+      });
+      const taskState = runningTask();
+      if (taskState) {
+        taskState.finalized = true;
+      }
+      eventBus.finished();
+    } finally {
+      const taskState = runningTask();
+      if (taskState?.finalized || taskState?.canceled) {
+        this.runningTasks.delete(requestContext.taskId);
       }
     }
   }
-  cancelTask = async () => {};
+  cancelTask = async (taskId, eventBus) => {
+    const taskState = this.runningTasks.get(taskId);
+    if (taskState?.finalized) {
+      return;
+    }
+    if (taskState) {
+      taskState.canceled = true;
+      taskState.finalized = true;
+    }
+    if (taskState?.sessionId) {
+      try {
+        await this.client.session.abort({ sessionID: taskState.sessionId });
+      } catch (error51) {
+        logger.warn({ error: error51, taskId }, "Failed to abort OpenCode session");
+      }
+    }
+    const contextId = taskState?.contextId ?? taskId;
+    eventBus.publish({
+      kind: "status-update",
+      taskId,
+      contextId,
+      status: {
+        state: "canceled",
+        message: {
+          kind: "message",
+          messageId: v4_default(),
+          role: "agent",
+          contextId,
+          taskId,
+          parts: [{ kind: "text", text: "Task canceled." }]
+        },
+        timestamp: new Date().toISOString()
+      },
+      final: true
+    });
+    eventBus.finished();
+  };
 }
 // ../../packages/a2a/index.ts
 class A2AServerPortInUseError extends Error {
@@ -71952,8 +72145,8 @@ class AgentRuntimeManager {
 import { resolve as resolve5 } from "path";
 // version.json
 var version_default = {
-  version: "0.2.0",
-  gitCommitHash: "0856eb3ca1182a69ce7bee3041695344cc61e73f"
+  version: "0.1.13",
+  gitCommitHash: "9e43945"
 };
 
 // src/commands/login/device-auth.ts
@@ -77356,9 +77549,7 @@ var userSandbox = pgTable("user_sandbox", {
   sandboxId: text("sandbox_id").notNull(),
   createdAt: timestamp("created_at").notNull(),
   updatedAt: timestamp("updated_at").$onUpdate(() => new Date).notNull()
-}, (table) => [
-  primaryKey({ columns: [table.userId, table.sandboxId] })
-]);
+}, (table) => [primaryKey({ columns: [table.userId, table.sandboxId] })]);
 var cliDevice = pgTable("cli_device", {
   id: text("id").primaryKey(),
   userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
@@ -77376,6 +77567,26 @@ var a2aAgent = pgTable("a2a_agent", {
   createdAt: timestamp("created_at").notNull(),
   updatedAt: timestamp("updated_at").$onUpdate(() => new Date).notNull()
 }, (table) => [index("a2a_agent_device_id_idx").on(table.deviceId)]);
+var a2aAgentTask = pgTable("a2a_agent_task", {
+  id: text("id").primaryKey(),
+  userId: text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
+  agentId: text("agent_id").notNull().references(() => a2aAgent.id, { onDelete: "cascade" }),
+  remoteTaskId: text("remote_task_id").notNull(),
+  contextId: text("context_id").notNull(),
+  status: text("status").notNull(),
+  prompt: text("prompt").notNull(),
+  resultText: text("result_text"),
+  artifacts: jsonb("artifacts"),
+  events: jsonb("events"),
+  metadata: jsonb("metadata"),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").$onUpdate(() => new Date).notNull(),
+  completedAt: timestamp("completed_at")
+}, (table) => [
+  index("a2a_agent_task_user_id_idx").on(table.userId),
+  index("a2a_agent_task_agent_id_idx").on(table.agentId),
+  uniqueIndex("a2a_agent_task_agent_remote_task_idx").on(table.agentId, table.remoteTaskId)
+]);
 var workerTask = pgTable("worker_task", {
   id: text("id").primaryKey(),
   taskType: text("task_type").notNull(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@obrain/cli",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,9 +22,9 @@
     "@types/node": "^20.14.15",
     "@types/yargs": "17.0.35",
     "bun-types": "^1.1.28",
-    "@repo/trpc": "0.0.0",
     "@repo/a2a": "0.0.0",
-    "@repo/better-auth": "0.0.0"
+    "@repo/better-auth": "0.0.0",
+    "@repo/trpc": "0.0.0"
   },
   "scripts": {
     "build": "bun build src/index.ts --outfile dist/index.js --target bun",