@awak-app/simy-cli 0.5.17 → 0.5.18

package/package.json

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

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.18";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/desktop-host.js

@@ -210,7 +210,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-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;
+}