@ai-setting/roy-task-plugin 0.7.14 → 0.7.16

package/dist/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "roy-task",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Roy — task-as-first-class-citizen harness for Claude Code. Ships the roy agent, slash commands for the task lifecycle, and an MCP server exposing the task tools natively.",
   "author": {
     "name": "dongzhaokun",

package/dist/claude-plugin/mcp/bridge.mjs

@@ -17,8 +17,12 @@ import { createTaskMcpServer } from "@ai-setting/roy-agent-core/env/task/mcp";
 import {
   TaskStoreBackend,
   createSQLiteTaskPort,
+  createRemoteTaskPortFromStore,
 } from "@ai-setting/roy-agent-core/env/task/backend";
-import { SQLiteTaskStore } from "@ai-setting/roy-agent-core/env/task/storage";
+import {
+  SQLiteTaskStore,
+  RemoteTaskStore,
+} from "@ai-setting/roy-agent-core/env/task/storage";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createNotifyDispatcher, taskIdFromResult } from "./task-notify-hooks.mjs";
@@ -59,8 +63,34 @@ export function defaultTaskDbPath() {
  * @param {{ cardNotifier?: object, decisionPort?: object, goalCheckTimeoutMs?: number }} deps test seams
  */
 export async function createServer(dbPath = defaultTaskDbPath(), deps = {}) {
-  const store = new SQLiteTaskStore(dbPath);
-  const backend = new TaskStoreBackend(createSQLiteTaskPort(store));
+  // Task #5569 — remote mode: when ROY_TASK_REMOTE_ENDPOINT is set,
+  // talk to the resident task-service over core's /store protocol
+  // instead of a local SQLite file. Same backend, same tools.
+  // The env var reaches this process because the claude runner
+  // spawns the MCP server with the daemon's full environment
+  // (mcp-notify.ts documents the inheritance).
+  let store, port;
+  const remoteEndpoint = process.env.ROY_TASK_REMOTE_ENDPOINT;
+  if (remoteEndpoint) {
+    const { readFile } = await import("node:fs/promises");
+    let authToken = process.env.ROY_TASK_REMOTE_TOKEN;
+    if (!authToken) {
+      try {
+        const auth = JSON.parse(
+          await readFile(join(homedir(), ".roy-agent", "auth.json"), "utf-8"),
+        );
+        authToken = auth.taskService?.authToken;
+      } catch {
+        // no auth.json — service may accept unauthenticated calls
+      }
+    }
+    store = new RemoteTaskStore({ endpoint: remoteEndpoint, authToken });
+    port = createRemoteTaskPortFromStore(store);
+  } else {
+    store = new SQLiteTaskStore(dbPath);
+    port = createSQLiteTaskPort(store);
+  }
+  const backend = new TaskStoreBackend(port);
   const server = createTaskMcpServer(backend, {
     name: "roy-task",
     version: "1.0.0",

package/dist/cli.js

@@ -1,7 +1,74 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// ../../../packages/cli/src/daemon/card-action-ports.ts
+var exports_card_action_ports = {};
+__export(exports_card_action_ports, {
+  toCoreTaskShape: () => toCoreTaskShape,
+  createTaskComponentAdapter: () => createTaskComponentAdapter
+});
+function toCoreTaskShape(task) {
+  const roy = task.roy ?? {};
+  const str = (v) => v === undefined || v === null ? undefined : String(v);
+  const pick = (key) => {
+    const top = task[key];
+    if (top !== undefined && top !== null)
+      return str(top);
+    return str(roy[key]);
+  };
+  const parentTop = task.parent_task_id;
+  return {
+    id: task.num ?? Number(task.id),
+    title: task.title,
+    ...task.description ? { description: task.description } : {},
+    ...pick("goals_and_expected_deliverables") !== undefined ? { goals_and_expected_deliverables: pick("goals_and_expected_deliverables") } : {},
+    ...pick("priority") !== undefined ? { priority: pick("priority") } : {},
+    ...pick("type") !== undefined ? { type: pick("type") } : {},
+    ...pick("project_path") !== undefined ? { project_path: pick("project_path") } : {},
+    ...typeof parentTop === "number" ? { parent_task_id: parentTop } : typeof roy.parent_task_id === "number" ? { parent_task_id: roy.parent_task_id } : { parent_task_id: null },
+    ...pick("current_status") !== undefined ? { current_status: pick("current_status") } : {},
+    ...pick("context") !== undefined ? { context: pick("context") } : {},
+    ...task.session_id ? { session_id: task.session_id } : {}
+  };
+}
+async function resolveByNum(store, num) {
+  if (typeof store.getTaskByNum === "function") {
+    return store.getTaskByNum(num);
+  }
+  const res = await store.listTasks({ limit: 1000 });
+  return res.tasks.find((t) => t.num === num || t.num === undefined && t.id === num) ?? null;
+}
+function createTaskComponentAdapter(store) {
+  return {
+    getTask: async (id) => {
+      const t = await resolveByNum(store, id);
+      return t ? toCoreTaskShape(t) : undefined;
+    },
+    updateTask: async (id, options) => {
+      const t = await resolveByNum(store, id);
+      if (!t)
+        throw new Error(`task #${id} not found`);
+      const isCoreShape = t.num === undefined;
+      return store.updateTask(t.id, options.context === undefined ? {} : isCoreShape ? { context: options.context } : { roy: { context: options.context } });
+    }
+  };
+}
+
 // ../../../packages/cli/src/daemon/runners/types.ts
 var RUNTIMES = Object.freeze(["opencode", "claude", "codex", "cursor"]);
 var DEFAULT_RUNTIME = "opencode";
@@ -1461,7 +1528,8 @@ var VALUE_FLAGS = new Set([
   "--codex-sandbox",
   "--cursor-model",
   "--max-concurrency",
-  "--timeout-ms"
+  "--timeout-ms",
+  "--task-store"
 ]);
 var SUBCOMMANDS = new Set(["serve", "status", "help", "version"]);
 function parseArgs(argv) {
@@ -1640,6 +1708,13 @@ function parseServe(argv) {
       case "--no-card":
         serve.cardEnabled = false;
         break;
+      case "--task-store": {
+        const v = take();
+        if (v instanceof Error)
+          return { command: "unknown", error: v.message };
+        serve.taskStoreEndpoint = v;
+        break;
+      }
       default:
         return { command: "unknown", error: `unknown flag "${flag}"` };
     }
@@ -2552,6 +2627,11 @@ function createEventListener(config) {
     profile: config.profile,
     eventKeys
   });
+  if (config.taskComponent) {
+    instance.setEnvironment?.({
+      getComponent: (name) => name === "task" ? config.taskComponent : undefined
+    });
+  }
   let callback;
   instance.onEvent((event) => {
     const typed = event;
@@ -2577,6 +2657,14 @@ function createEventListener(config) {
     plannedCommands() {
       const profileFlag = config.profile ? `--profile ${config.profile} ` : "";
       return eventKeys.map((k) => `lark-cli ${profileFlag}event consume ${k} --as bot`);
+    },
+    setTaskComponent(component) {
+      instance.setEnvironment?.({
+        getComponent: (name) => name === "task" ? component : undefined
+      });
+    },
+    hasCardActionPorts() {
+      return instance.hasCardActionPorts?.() ?? false;
     }
   };
 }
@@ -3338,6 +3426,38 @@ function getTraceRuntime(options) {
   return runtime;
 }
 
+// ../../../packages/cli/src/daemon/es-config.ts
+import { resolveEsFilePath } from "@ai-setting/roy-agent-core/env/event-source";
+async function readEventSourcesFile(configPath) {
+  try {
+    const { readFile } = await import("node:fs/promises");
+    const raw = await readFile(resolveEsFilePath(configPath), "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.sources) ? parsed.sources : [];
+  } catch {
+    return [];
+  }
+}
+async function resolveListenConfig(opts) {
+  const sources = await readEventSourcesFile(opts.configPath);
+  const larkSources = sources.filter((s) => s.type === "lark-cli" && s.enabled !== false);
+  const profile = opts.profile ?? larkSources.find((s) => s.profile)?.profile;
+  if (opts.eventKeys.length > 0) {
+    return { profile, eventKeys: [...opts.eventKeys], matchedSourceIds: [] };
+  }
+  const matched = larkSources.filter((s) => s.profile === profile && Array.isArray(s.eventKeys));
+  const keys = new Set;
+  for (const s of matched) {
+    for (const k of s.eventKeys ?? [])
+      keys.add(k);
+  }
+  return {
+    profile,
+    eventKeys: [...keys],
+    matchedSourceIds: matched.map((s) => s.id ?? "(unnamed)")
+  };
+}
+
 // ../../../packages/cli/src/cmd/serve.ts
 function serve(options, deps = {}) {
   return startServe(options, deps);
@@ -3368,10 +3488,44 @@ async function startServe(options, deps) {
     agent: options.agent,
     runtime: options.runtime
   });
-  const listener = (deps.createListener ?? createEventListener)({
+  const explicitKeys = options.eventKeys.length === 1 && options.eventKeys[0] === DEFAULT_EVENT_KEY ? [] : options.eventKeys;
+  const listen = await resolveListenConfig({
     profile: options.profile,
-    eventKeys: options.eventKeys
+    eventKeys: explicitKeys
+  });
+  if (listen.matchedSourceIds.length > 0) {
+    log(`[roy-task] event-sources.json: listening ${JSON.stringify(listen.eventKeys)} ` + `(profile=${listen.profile}, sources: ${listen.matchedSourceIds.join(", ")})`);
+  }
+  const listener = (deps.createListener ?? createEventListener)({
+    profile: listen.profile,
+    eventKeys: listen.eventKeys
   });
+  if (options.taskStoreEndpoint) {
+    try {
+      const { readFile } = await import("node:fs/promises");
+      const { homedir } = await import("node:os");
+      const { join: join4 } = await import("node:path");
+      const { createTaskPortFromConfig } = await import("@ai-setting/roy-agent-core/env/task/backend");
+      const { createTaskComponentAdapter: createTaskComponentAdapter2 } = await Promise.resolve().then(() => exports_card_action_ports);
+      let authToken;
+      try {
+        const auth = JSON.parse(await readFile(join4(homedir(), ".roy-agent", "auth.json"), "utf-8"));
+        authToken = auth.taskService?.authToken;
+      } catch {}
+      const wired = await createTaskPortFromConfig({
+        get: (key) => ({
+          "task.storage.type": "remote",
+          "task.storage.endpoint": options.taskStoreEndpoint,
+          "task.storage.authToken": authToken
+        })[key]
+      });
+      const store = wired.port;
+      listener.setTaskComponent(createTaskComponentAdapter2(store));
+      log(`[roy-task] card-action wired to ${options.taskStoreEndpoint}`);
+    } catch (err) {
+      log(`[roy-task] card-action wiring failed: ${errMsg5(err)} — card.action.trigger events will be skipped`);
+    }
+  }
   let eventCount = 0;
   let stopping;
   let resolveDone;
@@ -3395,7 +3549,7 @@ async function startServe(options, deps) {
   };
   const sweeper = setInterval(() => {
     deduper.sweep();
-  }, 5 * 60 * 1000);
+  }, 300000);
   if (typeof sweeper.unref === "function")
     sweeper.unref();
   listener.onEvent(async (event) => {
@@ -3469,13 +3623,13 @@ function formatResult(label, result) {
   const card = cardSuffix(result);
   switch (result.status) {
     case "dispatched":
-      return `[roy-task] ${label} dispatched  chat=${result.plan.chatId} session=${result.plan.sessionId} ` + `reply=${result.replyMessageId ?? "(no id)"} chars=${result.text.length}` + ` task=${result.taskId ?? "(none)"}${card}`;
+      return `[roy-task] ${label} dispatched  chat=${result.plan.chatId} session=${result.plan.sessionId} reply=${result.replyMessageId ?? "(no id)"} chars=${result.text.length} task=${result.taskId ?? "(none)"}${card}`;
     case "dry-run":
-      return `[roy-task] ${label} DRY-RUN  would run agent=${result.plan.agent} ` + `session=${result.plan.sessionId} chat=${result.plan.chatId} prompt=${result.plan.prompt.length}chars`;
+      return `[roy-task] ${label} DRY-RUN  would run agent=${result.plan.agent} session=${result.plan.sessionId} chat=${result.plan.chatId} prompt=${result.plan.prompt.length}chars`;
     case "duplicate":
       return `[roy-task] ${label} duplicate dropped key=${result.key ?? "(unknown)"}`;
     case "no-output":
-      return `[roy-task] ${label} no-output (agent produced no text; not replying) ` + `toolCalls=${result.toolCalls}${taskSuffix(result)}${card}`;
+      return `[roy-task] ${label} no-output (agent produced no text; not replying) toolCalls=${result.toolCalls}${taskSuffix(result)}${card}`;
     case "no-reply":
       return `[roy-task] ${label} no-reply (reply disabled) chars=${result.text.length}${taskSuffix(result)}${card}`;
     case "agent-error":
@@ -3611,7 +3765,7 @@ function formatStatus(report) {
 }
 
 // ../../../packages/cli/src/main.ts
-var VERSION = "0.7.14";
+var VERSION = "0.7.16";
 async function main(argv) {
   const parsed = parseArgs(argv);
   switch (parsed.command) {