slopwaresystems 0.4.15 → 0.4.16

package/dist/index.js

@@ -27144,7 +27144,7 @@ function persistRememberedConversation(cwd, conversation) {
   const directory = `${buildConversationPath(cwd)}.d`;
   persistLocalState(join3(directory, `${generateLocalStateKey(cwd, conversation.id)}.json`), JSON.stringify(conversation));
 }
-function fetchRememberedConversation(cwd, notBefore) {
+function fetchRememberedConversation(cwd, notBefore, harness) {
   const path2 = buildConversationPath(cwd);
   const candidates = [];
   let paths;
@@ -27158,12 +27158,13 @@ function fetchRememberedConversation(cwd, notBefore) {
     try {
       if (statSync(candidate).mtimeMs < notBefore) continue;
       const parsed = JSON.parse(readFileSync3(candidate, "utf8"));
-      const harness = AgentHarness.safeParse(parsed.harness ?? "other");
-      if (typeof parsed.id === "string" && parsed.id && harness.success) candidates.push({ id: parsed.id, harness: harness.data });
+      const wrote = AgentHarness.safeParse(parsed.harness ?? "other");
+      if (typeof parsed.id === "string" && parsed.id && wrote.success) candidates.push({ id: parsed.id, harness: wrote.data });
     } catch {
     }
   }
-  const distinct = [...new Map(candidates.map((candidate) => [candidate.id, candidate])).values()];
+  const mine = harness ? candidates.filter((candidate) => candidate.harness === harness) : candidates;
+  const distinct = [...new Map((mine.length ? mine : candidates).map((candidate) => [candidate.id, candidate])).values()];
   return distinct.length === 1 ? distinct[0] : null;
 }
 
@@ -27497,6 +27498,109 @@ function wakeCodexOverWs(text, threadId, endpoint) {
     });
   });
 }
+var CURSOR_TURN_CAP_MS = 6e5;
+var CURSOR_LOAD_WITHIN_MS = 3e4;
+function wakeCursor(text, chatId, cwd, options = {}) {
+  const binary = options.binary ?? "cursor-agent";
+  return wakeCursorOverAcp(text, chatId, cwd, binary).then((woken) => woken || resumeCursorChat(text, chatId, cwd, binary));
+}
+function wakeCursorOverAcp(text, chatId, cwd, binary) {
+  return new Promise((resolve6) => {
+    let child;
+    try {
+      child = spawn(binary, ["acp"], { cwd, stdio: ["pipe", "pipe", "ignore"] });
+    } catch {
+      resolve6(false);
+      return;
+    }
+    let settled = false;
+    let nextId = 1;
+    let buffer = "";
+    const finishWake = (woken, keepRunning = false) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(loadTimer);
+      if (!keepRunning) child.kill();
+      else setTimeout(() => child.kill(), CURSOR_TURN_CAP_MS).unref?.();
+      resolve6(woken);
+    };
+    const loadTimer = setTimeout(() => finishWake(false), CURSOR_LOAD_WITHIN_MS);
+    const send = (message) => {
+      try {
+        child.stdin?.write(`${JSON.stringify(message)}
+`);
+      } catch {
+        finishWake(false);
+      }
+    };
+    const call = (method, params) => {
+      const id = nextId++;
+      send({ jsonrpc: "2.0", id, method, params });
+      return id;
+    };
+    const initializeId = call("initialize", { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false }, clientInfo: { name: "slop", version: "0.4.16" } });
+    let loadId = 0;
+    let promptId = 0;
+    child.on("error", () => finishWake(false));
+    child.on("exit", () => finishWake(false));
+    child.stdout?.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      let index;
+      while ((index = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, index);
+        buffer = buffer.slice(index + 1);
+        if (!line.trim()) continue;
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (message.id !== void 0 && message.method === "session/request_permission") {
+          const options = message.params?.options ?? [];
+          const allow = options.find((option) => option.kind === "allow_once") ?? options.find((option) => /allow|accept/i.test(option.optionId ?? "")) ?? options[0];
+          send({ jsonrpc: "2.0", id: message.id, result: { outcome: { outcome: "selected", optionId: allow?.optionId ?? "allow" } } });
+          continue;
+        }
+        if (message.id !== void 0 && message.method) {
+          send({ jsonrpc: "2.0", id: message.id, result: {} });
+          continue;
+        }
+        if (message.id === initializeId) {
+          if (message.error) finishWake(false);
+          else loadId = call("session/load", { sessionId: chatId, cwd, mcpServers: [] });
+          continue;
+        }
+        if (message.id === loadId && loadId !== 0) {
+          if (message.error) finishWake(false);
+          else promptId = call("session/prompt", { sessionId: chatId, prompt: [{ type: "text", text }] });
+          continue;
+        }
+        if (promptId !== 0 && (message.id === promptId || message.method === "session/update")) finishWake(true, true);
+      }
+    });
+  });
+}
+function resumeCursorChat(text, chatId, cwd, binary) {
+  return new Promise((resolve6) => {
+    let child;
+    try {
+      child = spawn(binary, ["--resume", chatId, "-p", text, "--output-format", "text"], { cwd, stdio: ["ignore", "ignore", "ignore"] });
+    } catch {
+      resolve6(false);
+      return;
+    }
+    const timer = setTimeout(() => resolve6(true), 5e3);
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve6(false);
+    });
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve6(code === 0);
+    });
+  });
+}
 
 // src/platform/harness.ts
 var AgentHarnessValues = AgentHarness.options;
@@ -27648,6 +27752,31 @@ function resolveCodexBinary() {
   }
   return "codex";
 }
+function resolveParentHarness() {
+  return parseHarnessFromCommand(fetchParentCommand());
+}
+var RETRY_ACP_AFTER_MS = 5e3;
+var acpSession = null;
+function fetchCursorAcpSessionByCwd(cwd, binary = "cursor-agent") {
+  if (acpSession && (acpSession.id !== null || Date.now() - acpSession.at < RETRY_ACP_AFTER_MS)) return acpSession.id;
+  acpSession = { id: null, at: Date.now() };
+  const said = [
+    { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false }, clientInfo: { name: "slop", version: "0.4.16" } } },
+    { jsonrpc: "2.0", id: 2, method: "session/list", params: {} }
+  ];
+  try {
+    const answered = execFileSync3(binary, ["acp"], { input: `${said.map((message) => JSON.stringify(message)).join("\n")}
+`, encoding: "utf8", timeout: 15e3, stdio: ["pipe", "pipe", "ignore"], cwd });
+    for (const line of answered.split("\n")) {
+      if (!line.includes('"sessions"')) continue;
+      const listed = JSON.parse(line).result?.sessions ?? [];
+      const here = listed.filter((session) => typeof session.sessionId === "string" && typeof session.cwd === "string" && isSamePath(session.cwd, cwd));
+      if (here.length === 1) acpSession = { id: here[0].sessionId, at: Date.now() };
+    }
+  } catch {
+  }
+  return acpSession.id;
+}
 function fetchHarnessConversation(cwd) {
   const explicit = process.env.SLOP_CONVERSATION_ID?.trim();
   if (explicit) return { id: explicit, harness: AgentHarnessValues.includes(process.env.SLOP_HARNESS) ? process.env.SLOP_HARNESS : "other" };
@@ -27671,9 +27800,13 @@ var startedAt = Date.now();
 function fetchKnownConversation(cwd) {
   const own2 = fetchHarnessConversation(cwd);
   if (own2) return own2;
-  const remembered = fetchRememberedConversation(cwd, startedAt - 12e4);
+  const remembered = fetchRememberedConversation(cwd, startedAt - 12e4, resolveParentHarness());
   if (remembered?.harness === "codex" && isMainChatThread(fetchCodexHomes().map((home) => join8(home, "sessions")), remembered.id)) return remembered;
-  return remembered?.harness === "codex" ? null : remembered;
+  const known = remembered?.harness === "codex" ? null : remembered;
+  if (known) return known;
+  if (resolveParentHarness() !== "cursor") return null;
+  const acp = fetchCursorAcpSessionByCwd(cwd);
+  return acp ? { id: acp, harness: "cursor" } : null;
 }
 function resolveAgentIdentity(cwd, fallback = "process") {
   const conversation = fetchKnownConversation(cwd);
@@ -28877,6 +29010,67 @@ function parseToolCallFromCodexLine(line) {
   if (payload.type === "local_shell_call") return formatToolCallLine("shell", payload.action);
   return null;
 }
+function parseCursorTaskFromLine(line) {
+  if (!line.includes("CallDynamicTool") || !line.includes('"Task"')) return null;
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const content = entry.message?.content;
+  if (!Array.isArray(content)) return null;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const { type, name, input: input2 } = block;
+    if (type !== "tool_use" || name !== "CallDynamicTool" || input2?.toolName !== "Task") continue;
+    const asked = input2.arguments ?? {};
+    const prompt = typeof asked.prompt === "string" ? asked.prompt : null;
+    if (!prompt) continue;
+    const label = [asked.subagent_type, asked.description].filter((part) => typeof part === "string" && part.trim() !== "").join(" \u2014 ");
+    return { label: truncate(label || "subagent", WORKER_LABEL_MAX), prompt };
+  }
+  return null;
+}
+function parseCursorUserQuery(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const content = entry.message?.content;
+  if (entry.role !== "user" || !Array.isArray(content)) return null;
+  for (const block of content) {
+    const text = block?.text;
+    if (typeof text !== "string") continue;
+    const asked = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/.exec(text);
+    if (asked?.[1]) return asked[1];
+  }
+  return null;
+}
+function findCursorWorkerFiles(transcriptPath, conversation, changedAfter, asked) {
+  if (asked.length === 0) return [];
+  const directory = dirname7(dirname7(transcriptPath));
+  let chats;
+  try {
+    chats = readdirSync7(directory);
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const chat of chats) {
+    if (chat === conversation) continue;
+    const path2 = join14(directory, chat, `${chat}.jsonl`);
+    const changedAt = fetchChangedAt(path2);
+    if (changedAt < changedAfter) continue;
+    const query = parseCursorUserQuery(fetchFileHead(path2, 16 * 1024).split("\n")[0] ?? "");
+    const task = query === null ? void 0 : asked.find((candidate) => candidate.prompt === query);
+    if (!task) continue;
+    found.push({ ref: chat, label: task.label, path: path2, directory: null, branch: null, changedAt });
+  }
+  return found.sort((a, b) => b.changedAt - a.changedAt);
+}
 var fetchFileSize = (path2) => {
   try {
     return statSync4(path2).size;
@@ -29045,6 +29239,7 @@ function findCodexChildRollouts(roots, parentThreadId, changedAfter) {
   }
   return found;
 }
+var ASKED_CAP = 16;
 var HarnessActivity = class {
   constructor(conversation, onReport) {
     this.conversation = conversation;
@@ -29053,6 +29248,8 @@ var HarnessActivity = class {
   conversation;
   onReport;
   workers = /* @__PURE__ */ new Map();
+  /** What this chat has asked a subagent to do, which is how a Cursor chat's children are claimed. */
+  asked = [];
   own = null;
   doing = null;
   watched = false;
@@ -29070,10 +29267,7 @@ var HarnessActivity = class {
   setWatched(on) {
     if (on === this.watched) return;
     this.watched = on;
-    if (on) {
-      this.own = this.own && new FileTail(this.own.path);
-      for (const worker of this.workers.values()) worker.tail = new FileTail(worker.path);
-    }
+    if (on) this.doing = null;
     this.tick();
   }
   /** Say it again: the room forgets a session's activity when its socket drops, and only the agent can refill it. */
@@ -29089,6 +29283,10 @@ var HarnessActivity = class {
   tick() {
     if (this.stopped) return;
     const now = Date.now();
+    try {
+      this.read();
+    } catch {
+    }
     if (now - this.discoveredAt >= DISCOVER_EVERY_MS) {
       this.discoveredAt = now;
       try {
@@ -29096,12 +29294,6 @@ var HarnessActivity = class {
       } catch {
       }
     }
-    if (this.watched) {
-      try {
-        this.read();
-      } catch {
-      }
-    }
     const activity = this.build();
     const said = JSON.stringify(activity);
     if (said === this.reported) return;
@@ -29128,7 +29320,7 @@ var HarnessActivity = class {
     if (this.conversation.harness === "cursor") {
       const transcript = findCursorTranscriptPath(fetchCursorHomes(), this.conversation.id);
       this.own ??= transcript ? new FileTail(transcript, "end") : null;
-      return [];
+      return transcript ? findCursorWorkerFiles(transcript, this.conversation.id, changedAfter, this.asked) : [];
     }
     if (this.conversation.harness === "codex") {
       const roots = fetchCodexHomes().map((home) => join14(home, "sessions"));
@@ -29146,7 +29338,18 @@ var HarnessActivity = class {
       for (const line of tail.fetchNewLines()) newest = parse3(line) ?? newest;
       return newest;
     };
-    if (this.own) this.doing = findNewestCall(this.own) ?? this.doing;
+    if (this.own) {
+      let newest = null;
+      for (const line of this.own.fetchNewLines()) {
+        newest = parse3(line) ?? newest;
+        const task = this.conversation.harness === "cursor" ? parseCursorTaskFromLine(line) : null;
+        if (task) {
+          this.asked.push(task);
+          while (this.asked.length > ASKED_CAP) this.asked.shift();
+        }
+      }
+      this.doing = newest ?? this.doing;
+    }
     for (const worker of this.workers.values()) worker.doing = findNewestCall(worker.tail) ?? worker.doing;
   }
   build() {
@@ -29708,7 +29911,7 @@ function createProjectTools(api, project, identity) {
     if (waking || stopped) return;
     waking = true;
     const text = `Messages are waiting for you on Slopware Tasks in project ${project.key}. Use session check with project ${project.id} to read them, then act or reply only if it changes something. Do not acknowledge.`;
-    const wake = identity.harness === "codex" && identity.conversation ? wakeCodex(text, identity.conversation, { binary: resolveCodexBinary(), codexHome: resolveOwnHarnessHome("CODEX_HOME") }) : identity.harness === "claude" ? wakeHarness(text, void 0, identity.conversation) : Promise.resolve(false);
+    const wake = identity.harness === "codex" && identity.conversation ? wakeCodex(text, identity.conversation, { binary: resolveCodexBinary(), codexHome: resolveOwnHarnessHome("CODEX_HOME") }) : identity.harness === "claude" ? wakeHarness(text, void 0, identity.conversation) : identity.harness === "cursor" && identity.conversation ? wakeCursor(text, identity.conversation, process.cwd()) : Promise.resolve(false);
     void wake.catch(() => false).finally(() => {
       waking = false;
     });
@@ -30269,7 +30472,7 @@ async function trustCodexHooks(codexHome) {
   const sendNotification = (method, params) => server.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   try {
-    await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0.4.15" }, capabilities: { experimentalApi: true } });
+    await callCodexMethod("initialize", { clientInfo: { name: "slop", version: "0.4.16" }, capabilities: { experimentalApi: true } });
     sendNotification("initialized", {});
     const listed = await callCodexMethod("hooks/list", { cwds: [process.cwd()] });
     const ours = listed.data.flatMap((entry) => entry.hooks).filter((hook) => hook.command?.startsWith("slop hook "));
@@ -30285,7 +30488,8 @@ async function trustCodexHooks(codexHome) {
     server.kill();
   }
 }
-async function parseHookInput(harness, remember = true) {
+async function parseHookInput(installedAs, remember = true) {
+  const harness = resolveParentHarness() ?? installedAs;
   const input2 = await new Promise((resolve6) => {
     let data = "";
     process.stdin.on("data", (chunk) => data += chunk);
@@ -30302,7 +30506,7 @@ async function parseHookInput(harness, remember = true) {
   }
   const ownThread = harness !== "codex" || !conversation || isMainChatThread(fetchCodexHomes().map((home) => join16(home, "sessions")), conversation);
   if (remember && conversation && ownThread && !isNonInteractiveHarness()) persistRememberedConversation(cwd, { id: conversation, harness: harness ?? "other" });
-  return { cwd, conversation };
+  return { cwd, conversation, harness };
 }
 async function runPromptHook(harness) {
   await parseHookInput(harness);
@@ -30310,11 +30514,11 @@ async function runPromptHook(harness) {
 async function runToolHook(harness) {
   await parseHookInput(harness, false);
 }
-async function runStartHook(harness) {
+async function runStartHook(installedAs) {
   if (isNonInteractiveHarness()) return;
-  const { conversation } = await parseHookInput(harness);
+  const { conversation, harness } = await parseHookInput(installedAs);
   if (!conversation) return;
-  const carried = harness === "codex" ? " (no wait tool on Codex; a reply becomes your next turn)" : harness === "cursor" ? " (nothing wakes an idle chat here: a message reaches you with your next slop tool call)" : "";
+  const carried = harness === "codex" ? " (no wait tool on Codex; a reply becomes your next turn)" : harness === "cursor" ? " (no wait tool on Cursor; a message for you arrives as a new turn in this chat)" : "";
   const text = `On Slopware Tasks you are ${generateAgentName(conversation)}: that is how people and other agents address you (session who lists everyone). Messages between agents are letters, read when the other side gets to them: write once, reply only when it changes something, never wait for a reply${carried}.`;
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: text }, additional_context: text })}
 `);
@@ -30556,13 +30760,13 @@ ${written.map((path2) => `  ${path2}`).join("\n")}`);
 }
 
 // src/index.ts
-var program2 = new Command().name("slop").description("Slopware Tasks from the terminal. Everything a person can do on the board, an agent can do here.").version("0.4.15").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => updateJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
+var program2 = new Command().name("slop").description("Slopware Tasks from the terminal. Everything a person can do on the board, an agent can do here.").version("0.4.16").option("--json", "machine-readable output: JSON on stdout, errors as JSON on stderr").hook("preAction", (_, action) => updateJsonMode(Boolean(action.optsWithGlobals().json))).showHelpAfterError("(run with --help for usage)");
 registerAuthCommands(program2);
 registerProjectCommands(program2);
 var taskCommand = registerTaskCommands(program2);
 registerSessionCommands(program2);
 registerThreadCommands(program2, taskCommand);
-registerMcpCommands(program2, "0.4.15");
+registerMcpCommands(program2, "0.4.16");
 registerGuideCommand(program2);
 registerSkillCommands(program2);
 program2.parseAsync().catch(exitWithError);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopwaresystems",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "private": false,
   "description": "slop: the Slopware Tasks board from the terminal, for people and coding agents.",
   "type": "module",