@awak-app/simy-cli 0.5.17 → 0.5.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.5.17",
+  "version": "0.5.19",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -53,6 +53,7 @@ import {
   createConnectionStatusTracker,
   desktopAuthStatus,
   desktopTaskStatus,
+  desktopTaskDetail,
 } from "./desktop-status.js";
 import { recoveryContractForPreflight } from "./orchestrator/recovery.js";
 import {
@@ -1661,6 +1662,7 @@ export async function startAgent({
     },
     requestDesktopLogin,
     getDesktopStatus,
+    getDesktopTask: (key) => desktopTaskDetail([registry, directRegistry, localTaskRegistry], key),
     async refreshDesktopStatus() {
       if (isSessionValid(session, Date.now(), apiOrigin)) {
         await heartbeat().catch((error) => reportHeartbeatError(error, quiet));

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.5.17";
+export const CLI_VERSION = "0.5.19";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/desktop-host.js

@@ -144,6 +144,12 @@ export async function startDesktopHost({ input = process.stdin, output = process
     queue = queue.then(async () => {
       try {
         const action = command.action;
+        if (action === "task_detail") {
+          const task = await agent.getDesktopTask?.(command.taskKey);
+          emit({ type: "task_detail", id: command.id, taskKey: command.taskKey, task: task ?? null });
+          emit({ type: "result", id: command.id, ok: Boolean(task) });
+          return;
+        }
         if (action === "refresh" || action === "reconnect") {
           await agent.refreshCodexStatus?.();
           await agent.refreshDesktopStatus();
@@ -210,7 +216,7 @@ if (isDesktopHostEntry()) {
     const conflict = error?.code === PROCESS_CONFLICT_CODE;
     process.stdout.write(`${JSON.stringify({
       type: "error",
-      ...(conflict ? { code: PROCESS_CONFLICT_CODE } : {}),
+      ...(conflict ? { code: PROCESS_CONFLICT_CODE, conflicts: error.conflicts || [] } : {}),
       message: conflict
         ? PROCESS_CONFLICT_MESSAGE
         : "SIMY could not start. Check whether another SIMY window is already running, then reconnect.",

package/src/desktop-process-lock.js

@@ -10,10 +10,11 @@ export const PROCESS_CONFLICT_MESSAGE =
   "Another SIMY background service is already running for this Web address. Stop the existing CLI daemon, then reopen SIMY CLI.";
 
 export class SimyProcessConflictError extends Error {
-  constructor(message = PROCESS_CONFLICT_MESSAGE) {
+  constructor(message = PROCESS_CONFLICT_MESSAGE, conflicts = []) {
     super(message);
     this.name = "SimyProcessConflictError";
     this.code = PROCESS_CONFLICT_CODE;
+    this.conflicts = conflicts;
   }
 }
 
@@ -96,12 +97,13 @@ export async function assertNoDesktopHostForOrigin(
   throw new SimyProcessConflictError();
 }
 
-export async function assertNoLegacyCliDaemon(
+export async function findLegacyCliDaemons(
   webOrigin,
   {
     processes = listSameUserProcesses,
     verifyEntry = verifySimyCliEntry,
     currentPid = process.pid,
+    identity = processStart,
   } = {},
 ) {
   const requestedOrigin = normalizeWebOrigin(webOrigin);
@@ -113,13 +115,48 @@ export async function assertNoLegacyCliDaemon(
       "SIMY could not verify whether another CLI service is running. Stop the existing CLI daemon, then reopen SIMY CLI.",
     );
   }
+  const conflicts = [];
   for (const processInfo of candidates) {
-    if (processInfo.pid === currentPid) continue;
+    if (!Number.isSafeInteger(processInfo.pid) || processInfo.pid <= 0 || processInfo.pid === currentPid) continue;
     const parsed = parseLegacyAgentArguments(processInfo.command ?? processInfo.args);
     if (!parsed || !(await verifyEntry(parsed.entryPath))) continue;
     if (parsed.webOrigin && parsed.webOrigin !== requestedOrigin) continue;
-    throw new SimyProcessConflictError();
+    const startedAt = await identity(processInfo.pid).catch(() => null);
+    conflicts.push({ pid: processInfo.pid, entryPath: parsed.entryPath, startedAt });
   }
+  return conflicts;
+}
+
+
+export async function assertNoLegacyCliDaemon(webOrigin, options) {
+  const conflicts = await findLegacyCliDaemons(webOrigin, options);
+  if (conflicts.length) throw new SimyProcessConflictError(PROCESS_CONFLICT_MESSAGE, conflicts);
+}
+
+// Re-discover same-user SIMY processes and compare their start time immediately
+// before signaling. A PID alone is never sufficient authorization after a dialog.
+export async function stopConfirmedCliConflicts(webOrigin, approved, { force = false,
+  discover = findLegacyCliDaemons, signal = process.kill.bind(process),
+  alive = processAlive, wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+} = {}) {
+  if (!Array.isArray(approved) || !approved.length || approved.length > 100) throw new Error("No confirmed SIMY process.");
+  const stopped = [];
+  for (const expected of approved) {
+    if (!Number.isSafeInteger(expected.pid) || expected.pid <= 0 || !expected.startedAt || typeof expected.entryPath !== "string") {
+      throw new Error("SIMY process identity is unavailable. Refresh and try again.");
+    }
+    const current = (await discover(webOrigin)).find((item) => item.pid === expected.pid);
+    if (!current) continue;
+    if (current.startedAt !== expected.startedAt || current.entryPath !== expected.entryPath) {
+      throw new Error("The process changed. Refresh before stopping it.");
+    }
+    try { signal(current.pid, force ? "SIGKILL" : "SIGTERM"); }
+    catch (error) { if (error.code !== "ESRCH") throw error; }
+    stopped.push(current);
+  }
+  for (let n = 0; n < 40 && stopped.some((item) => alive(item.pid)); n++) await wait(250);
+  const remaining = await discover(webOrigin);
+  return { remaining: remaining.filter((item) => stopped.some((old) => old.pid === item.pid && old.startedAt === item.startedAt && old.entryPath === item.entryPath)) };
 }
 
 export function parseLegacyAgentArguments(args) {

package/src/desktop-status.js

@@ -83,6 +83,42 @@ export function desktopTaskStatus(registries, { maxItems = MAX_STATUS_ITEMS } =
   };
 }
 
+// Detail is sent only on selection, never in the periodic metadata broadcast.
+export function desktopTaskDetail(registries, key) {
+  if (typeof key !== "string" || key.length > 256) return null;
+  const match = /^(\d+):(.+)$/.exec(key);
+  if (!match) return null;
+  const registryIndex = Number(match[1]);
+  const task = registries[registryIndex]?.list?.().find((item) => item.id === match[2]);
+  if (!task) return null;
+  const attempt = task.snapshot?.attempts?.at(-1);
+  const request = task.request?.requirement || task.instruction || task.snapshot?.charter?.requirement;
+  const result = typeof task.result === "string" ? task.result : task.result?.summary || attempt?.summary;
+  const links = [];
+  const pr = safeDesktopLink(attempt?.pr_url);
+  if (pr) links.push({ label: "Pull request", url: pr });
+  return {
+    key,
+    instruction: desktopContent(request),
+    result: desktopContent(result),
+    error: desktopContent(task.error, 1000),
+    truncated: [request, result].some((value) => typeof value === "string" && value.length > 16000),
+    links,
+  };
+}
+
+function desktopContent(value, limit = 16000) {
+  // Preserve paragraphs/Markdown, but never serialize runtime objects or logs.
+  return typeof value === "string" ? value.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "").slice(0, limit) : "";
+}
+
+function safeDesktopLink(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password ? url.href : null;
+  } catch { return null; }
+}
+
 export function createCodexStatusInspector({
   cacheMs = CODEX_STATUS_CACHE_MS,
   inspect = inspectCodexStatus,
@@ -178,6 +214,7 @@ function taskStatusItem(task, registryIndex) {
     48,
   );
   return {
+    key: `${registryIndex}:${bounded(task?.id || "", 240)}`,
     id: bounded(String(task?.id || `unknown-${registryIndex}`), MAX_LABEL_LENGTH),
     label: bounded(
       String(

package/src/desktop-stop-conflicts.js

@@ -0,0 +1,17 @@
+import { stopConfirmedCliConflicts } from "./desktop-process-lock.js";
+import { resolveWebOrigin } from "./web-origin.js";
+
+// Invoked by the native confirmation dialog, never automatically at startup.
+let input = "";
+try {
+  for await (const chunk of process.stdin) {
+    input += chunk;
+    if (input.length > 32768) throw new Error("Confirmation is too large.");
+  }
+  const request = JSON.parse(input);
+  const result = await stopConfirmedCliConflicts(resolveWebOrigin(null, process.env), request.conflicts, { force: request.force === true });
+  process.stdout.write(JSON.stringify({ ok: true, ...result }));
+} catch {
+  process.stdout.write(JSON.stringify({ ok: false }));
+  process.exitCode = 1;
+}