@awak-app/simy-cli 0.7.32 → 0.7.34

package/src/session-supervision/remote-hosts.js

@@ -7,6 +7,7 @@ import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { compareSessionWork } from './work-state.js';
 import { manualAcceptanceCommand, matchesManualAcceptanceControls, manualAcceptanceContinuation } from './manual-acceptance-command.js';
+import { remoteHostRecovery } from './remote-host-recovery.js';
 
 const MAX_FRAME = 8 * 1024 * 1024;
 const MAX_HOSTS = 8;
@@ -83,9 +84,10 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
   let preferenceScope = null;
   let scope = null, local = null, closed = false, settingsError = null, writes = Promise.resolve(), generation = 0;
   const changed = () => { if (!closed) onChange(); };
-  function disconnect(connection, reason = 'Remote connection closed.') {
+  function disconnect(connection, reason = 'Remote connection closed.', errorCode = 'transport_unavailable') {
     const child = connection.child;
     connection.child = null; connection.ready = false; connection.reason = reason; connection.state = 'unavailable'; connection.retryAt = now() + retryMs;
+    connection.errorCode = errorCode;
     clearTimeout(connection.handshake);
     for (const job of connection.pending.values()) { clearTimeout(job.timer); job.reject(error('Remote operation result is unknown. Check the original conversation before retrying.', 'remote_operation_unknown')); }
     connection.pending.clear();
@@ -106,7 +108,8 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
     const id = `${connection.id}:${frame.id}`;
     return preferences.change(expectedScope, state => {
       if (state.events[id] || closed || preferenceScope !== expectedScope || !connection.ready) return;
-      onNotify({ ...stamp(event, connection), hostId: connection.id, id });
+      onNotify({ ...stamp(event, connection), hostId: connection.id, id,
+        ...(event.continuationWaitId ? { sessionIdentity: `${event.provider}|${event.session}|${connection.id}` } : {}) });
       state.events[id] = now();
     });
   }
@@ -139,7 +142,7 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
   }
   function connect(connection) {
     if (closed || connection.enabled === false || connection.child || now() < connection.retryAt) return;
-    connection.state = 'connecting'; connection.reason = null;
+    connection.state = 'connecting'; connection.reason = null; connection.errorCode = null;
     let child;
     try { child = spawnImpl('ssh', remoteSshArgs(connection.alias, REMOTE_HOST_COMMAND), { stdio: ['pipe', 'pipe', 'pipe'], shell: false }); }
     catch { disconnect(connection, 'Could not start SSH.'); return; }
@@ -175,10 +178,11 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
           connection.capabilities = Array.isArray(status?.remoteControl?.actions)
             ? status.remoteControl.actions.filter(action => typeof action === 'string' && allowedActions.has(action))
             : status?.remoteControl === undefined && status?.remoteSessionProtocol === 1 ? [...legacyActions] : [];
-          if (status?.remoteSessionProtocol !== 1) { disconnect(connection, 'Update SIMY on the remote host to use remote sessions.'); changed(); return; }
+          if (status?.remoteSessionProtocol !== 1) { disconnect(connection, 'Update SIMY on the remote host to use remote sessions.', 'update_required'); changed(); return; }
           if (!usable(status) || status.auth.userId !== local?.auth?.userId || status.access.organizationId !== local?.access?.organizationId) {
             clearTimeout(connection.handshake);
             connection.ready = false; connection.state = 'access_required'; connection.reason = 'Use Remote connections in this CLI to sign in to this host.';
+            connection.errorCode = status?.auth?.state !== 'signed_in' ? 'simy_auth_required' : 'access_required';
             connection.status = null;
             for (const [id, job] of connection.pending) if (!job.setup) { clearTimeout(job.timer); job.reject(error(connection.reason, 'remote_operation_unknown')); connection.pending.delete(id); }
           } else if (!Array.isArray(status.sessionSupervision?.sessions) || !Array.isArray(status.deliveryHooks?.runs)) {
@@ -186,6 +190,7 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
           } else {
             clearTimeout(connection.handshake);
             connection.status = status; connection.ready = true; connection.state = 'ready'; connection.reason = null; connection.receivedAt = now();
+            connection.errorCode = null;
             if (status.controllerEventsVersion === 1) void pullEvents(connection).catch(() => {});
             else for (const event of status.controllerEvents || []) void receiveNotification(connection, event)?.catch(() => {});
             const expectedScope = preferenceScope;
@@ -210,7 +215,7 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
         } else if (frame.type === 'notify' && connection.ready && local && typeof frame.id === 'string' && ['finished','failed','paused','needs_decision'].includes(frame.kind)) {
           void receiveNotification(connection, frame)?.catch(() => {});
         } else if (frame.type === 'error') {
-          disconnect(connection, remoteOperationFailure(frame.code).message); changed(); return;
+          disconnect(connection, remoteOperationFailure(frame.code).message, frame.code === 'remote_owner_origin_mismatch' ? 'access_required' : 'transport_unavailable'); changed(); return;
         } else if (frame.type === 'task_detail') {
           const pending = connection.pending.get(frame.id);
           pending?.onDetail?.({ ...frame, id: pending.id, taskKey: pending.taskKey });
@@ -252,7 +257,7 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
       c.label = host.label; c.enabled = host.enabled !== false;
       if (!c.enabled) {
         if (c.child) disconnect(c);
-        c.ready = false; c.status = null; c.state = 'disconnected'; c.reason = null;
+        c.ready = false; c.status = null; c.state = 'disconnected'; c.reason = null; c.errorCode = null;
         continue;
       }
       if (c.state === 'disconnected') c.retryAt = 0;
@@ -339,8 +344,22 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
       if (!c) return;
       c.enabled = enabled;
       if (!enabled) { disconnect(c); c.status = null; c.state = 'disconnected'; c.reason = null; }
-      else { c.retryAt = 0; if (c.state === 'disconnected') c.state = 'connecting'; }
+      else {
+        // Explicit Connect also retries a stale or unauthorized live transport.
+        // Resetting backoff alone cannot replace a child that is still present.
+        // Keep healthy connections and an in-flight handshake intact.
+        if (c.child && c.state !== 'connecting' && (!c.ready || now() - c.receivedAt > 45_000)) disconnect(c);
+        c.retryAt = 0;
+        if (!c.child) c.state = 'connecting';
+      }
     });
+    const c = connections.get(host.id);
+    if (enabled && c?.child && c.capabilities?.includes('refresh')) {
+      // Explicit Connect/Check again must request a new host observation even
+      // when SSH is healthy. Keep its owner and in-flight mutation receipts:
+      // refreshing providers is read-only and must never replay execution.
+      c.child.stdin.write(JSON.stringify({ id: randomUUID(), action: 'refresh' }) + '\n');
+    }
   }
   async function forward(command, status) {
     if (closed || !usable(status) || scopeOf(status) !== scope) throw error('SIMY account changed. Refresh before using the remote host.', 'remote_host_access');
@@ -478,7 +497,8 @@ export function createRemoteHostManager({ root, store, spawnImpl = spawn, onChan
       const remoteActiveCount = hosts.filter(c => c.ready).reduce((n,c) => n + (c.status?.[key]?.activeCount || 0), 0);
       return { ...status[key], items: [...localItems, ...rows], localActiveCount: Math.max(0, (status[key]?.activeCount || 0) - priorRemote), activeCount: Math.max(0, (status[key]?.activeCount || 0) - priorRemote) + remoteActiveCount, remoteActiveCount, unknownHosts: hosts.filter(c => !c.ready).map(c => c.id) };
     }
-    return { ...status, remoteHosts: { error: settingsError, items: hosts.map(c => ({ id: c.id, alias: c.alias, label: c.label, enabled: c.enabled !== false, state: c.ready && now() - c.receivedAt > 45_000 ? 'unavailable' : c.state, transportId: c.ready ? c.transportId : null, reason: c.reason })) },
+    return { ...status, remoteHosts: { error: settingsError, items: hosts.map(c => ({ id: c.id, alias: c.alias, label: c.label, enabled: c.enabled !== false, state: c.ready && now() - c.receivedAt > 45_000 ? 'unavailable' : c.state, transportId: c.ready ? c.transportId : null, reason: c.reason,
+      recovery: remoteHostRecovery({ state: c.state, enabled: c.enabled, status: c.status, ready: c.ready, fresh: now() - c.receivedAt <= 45_000, errorCode: c.errorCode }) })) },
       tasks: aggregate('tasks', tasks), sqmTasks: aggregate('sqmTasks', sqmTasks),
       sessionSupervision: { ...status.sessionSupervision, selectionCandidates: [...(status.sessionSupervision?.selectionCandidates || []).filter(row => !row.hostId || row.hostId === 'local'), ...selectionCandidates], sessions: [...(status.sessionSupervision?.sessions || []).filter(row => !row.hostId || row.hostId === 'local'), ...sessions].sort(compareSessionWork) },
       deliveryHooks: { ...status.deliveryHooks, runs: [...(status.deliveryHooks?.runs || []).filter(row => !row.hostId || row.hostId === 'local'), ...runs] } };

package/src/session-supervision/remote-owner-entry.js

@@ -0,0 +1,20 @@
+// Separate from the SSH entry so reconnects only attach and never replace work.
+import { PassThrough, Writable } from 'node:stream';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { adoptInstalledRuntime, pinnedWorkflowSource } from '../delivery-hooks/local-runtime.js';
+
+process.env.SIMY_REMOTE_CHILD = '1';
+process.env.SIMY_AUTO_UPDATE = '0';
+const root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy');
+try {
+  await adoptInstalledRuntime({ root });
+  const selected = await pinnedWorkflowSource({ root });
+  const host = await import(selected ? pathToFileURL(join(selected, 'src/desktop-host.js')).href : '../desktop-host.js');
+  if (host.remoteSessionProtocol !== 1) throw new Error('Update the remote SIMY runtime.');
+  host.startDesktopEntry({ input: new PassThrough(), output: new Writable({ write(_chunk, _encoding, done) { done(); } }) });
+} catch (error) {
+  process.stderr.write(`Remote SIMY owner could not start: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/src/session-supervision/remote-service.js

@@ -0,0 +1,36 @@
+import { spawn } from 'node:child_process';
+import { mkdir, open } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { relayToOwner } from './owner-transport.js';
+
+// The SSH viewer is disposable; the ordinary locked desktop owner is not.
+// Startup contenders use the existing desktop lock, never remove it or stop an
+// owner. A lost viewer must not turn into a repeated execution command.
+export async function attachRemoteService({ root, webOrigin, input = process.stdin, output = process.stdout,
+  relay = relayToOwner, spawnImpl = spawn, timeoutMs = 30_000, retryMs = 200 } = {}) {
+  if (await relay({ root, webOrigin, input, output })) return;
+  await mkdir(join(root, 'logs'), { recursive: true, mode: 0o700 });
+  const log = await open(join(root, 'logs', 'remote-service.log'),
+    constants.O_WRONLY | constants.O_CREAT | constants.O_APPEND | (constants.O_NOFOLLOW || 0), 0o600);
+  try {
+    const env = { ...process.env, SIMY_HOME: root, SIMY_WEB_ORIGIN: webOrigin,
+      SIMY_REMOTE_CHILD: '1', SIMY_AUTO_UPDATE: '0' };
+    // A viewer cannot hand its update-candidate exemption to a new owner.
+    delete env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
+    delete env.SIMY_UPDATE_TRANSFER_TOKEN;
+    const child = spawnImpl(process.execPath, [fileURLToPath(new URL('./remote-owner-entry.js', import.meta.url))], {
+      detached: true, stdio: ['ignore', log.fd, log.fd],
+      env,
+    });
+    await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
+    child.unref();
+  } finally { await log.close(); }
+  const until = Date.now() + timeoutMs;
+  while (Date.now() < until) {
+    if (await relay({ root, webOrigin, input, output })) return;
+    await new Promise(resolve => setTimeout(resolve, retryMs));
+  }
+  throw Object.assign(new Error('Remote SIMY did not start. Inspect logs/remote-service.log; existing work was retained.'), { code: 'remote_owner_unavailable' });
+}

package/src/session-supervision/statistics.js

@@ -10,6 +10,8 @@ export const unavailableStatistics = () => ({ state: 'unavailable', hours: [], a
 const READ_BYTES = 1024 * 1024;
 const MAX_LINE_BYTES = 4 * READ_BYTES;
 const WINDOW_MS = 7 * 24 * HOUR;
+const CODEX_WORK_EVENTS = new Set(['task_started', 'task_complete', 'task_aborted', 'turn_aborted',
+  'item_completed', 'user_message', 'agent_message', 'agent_reasoning', 'agent_reasoning_raw_content']);
 // One selected transcript only; no raw messages or on-disk cache. Identity and
 // ctime prevent reuse after replacement/truncation even when size is unchanged.
 let cachedTranscript;
@@ -54,6 +56,15 @@ class StatisticsAccumulator {
     const key = `codex:${at}:${total}`;
     if (delta > 0 || !this.usage.has(key)) this.usage.set(key, { at, tokens: delta });
   }
+  addOversized(prefix) {
+    // Only the canonical Codex response envelope is safe to dismiss here:
+    // response items contain activity, not cumulative usage or session identity.
+    // Keep unknown headers and oversized counters/metadata incomplete.
+    const header = /^\s*\{\s*"timestamp"\s*:\s*"([^"\\]+)"\s*,\s*(?:"ordinal"\s*:\s*\d+\s*,\s*)?"type"\s*:\s*"response_item"\s*,/.exec(prefix.subarray(0, 1024).toString('utf8'));
+    const at = header ? Date.parse(header[1]) : NaN;
+    if (this.provider === 'codex' && Number.isFinite(at) && at < this.scanNow - WINDOW_MS) return;
+    this.missing = true;
+  }
   add(line) {
     if (!line.trim()) return;
     let row;
@@ -77,7 +88,7 @@ class StatisticsAccumulator {
     if (!Number.isFinite(at)) return;
     const inWindow = at >= this.scanNow - WINDOW_MS;
     const active = this.provider === 'claude' ? ['user', 'assistant'].includes(row.type) && !row.isMeta
-      : ['response_item', 'event_msg'].includes(row.type) && row.payload?.type !== 'token_count';
+      : row.type === 'response_item' || row.type === 'event_msg' && CODEX_WORK_EVENTS.has(row.payload?.type);
     if (active) {
       this.earliest = Math.min(this.earliest, at);
       if (inWindow) this.events.push(at);
@@ -189,7 +200,7 @@ async function readReverse(handle, size, accumulator, signal) {
     for (let index = data.lastIndexOf(10); index >= 0; index = data.lastIndexOf(10, index - 1)) {
       const line = data.subarray(index + 1, end);
       if (!skipping && line.length <= MAX_LINE_BYTES) accumulator.add(line.toString('utf8'));
-      else accumulator.missing = true;
+      else accumulator.addOversized(line);
       skipping = false; end = index;
       // Disk I/O alone does not yield while parsing a dense page. Keep status,
       // selection and cancellation responsive even for huge cached transcripts.
@@ -200,10 +211,15 @@ async function readReverse(handle, size, accumulator, signal) {
       }
       if (index === 0) break;
     }
-    if (end > MAX_LINE_BYTES || skipping) { carry = Buffer.alloc(0); skipping = true; accumulator.missing = true; }
+    if (end > MAX_LINE_BYTES || skipping) {
+      // Retain a bounded prefix until the start of this line is reached. The
+      // prefix may straddle a page, so keep the adjacent bytes when skipping.
+      carry = Buffer.from(data.subarray(0, Math.min(end, 1024))); skipping = true;
+    }
     else carry = Buffer.from(data.subarray(0, end));
   }
   if (!skipping) accumulator.add(carry.toString('utf8'));
+  else accumulator.addOversized(carry);
   return bytesRead;
 }
 

package/src/session-supervision/work-state.js

@@ -85,7 +85,13 @@ export function sessionWorkState(candidate, run, { now = Date.now(), provider }
   const phase = run?.phase || run?.managed?.phase;
   const stopped = run?.state === 'stopped' || run?.stopReason?.actor === 'user' ||
     run?.state === 'paused' && /^(Paused by user\.|Automatic continuation paused by user\.|User interrupted the provider\.|Stopped by user\.)$/.test(run.reason || '');
-  if (stopped) return result('stopped', '自分で停止', '停止の指示を維持しています。', 'resume');
+  if (stopped) {
+    if (run?.reason === 'User interrupted the provider.' && run?.stopReason?.actor !== 'user')
+      return result('stopped', '中断を検出', '元のAIから中断が通知されました。本人による停止操作かは確認できません。', 'resume', true);
+    if (run?.stopReason?.actor === 'user' || /^(Stopped by user\.|Paused by user\.|Automatic continuation paused by user\.)$/.test(run?.reason || ''))
+      return result('stopped', '自分で停止', '停止の指示を維持しています。', 'resume');
+    return result('stopped', '停止中', '停止理由を確認してから再開してください。', 'resume', true);
+  }
   if (approval && !approval.denied || candidate.decisionRequest?.kind === 'approval')
     return result('approval', '承認待ち', candidate.decisionRequest?.context || '実行する操作の確認が必要です。', 'review_approval', true);
   if (question || phase === 'needs_clarification' || candidate.analysis?.state === 'needs_user' || candidate.decisionRequest?.kind === 'question')

package/src/sqm/local-tests.js

@@ -16,7 +16,8 @@ const profiles = {
     // finite catalog-owned deadline while allowing slow local process I/O.
     { id: 'repair-and-stop-boundaries', timeoutMs: 1_200_000, files: ['test/purpose-search.test.js', 'test/delivery-explicit-resume.test.js', 'test/purpose-continuation.test.js'] },
     { id: 'sqm-runner', files: ['test/sqm-local-tests.test.js'] },
-    { id: 'provider-startup', files: ['test/codex-app-server-discovery.test.js', 'test/session-supervision.test.js'] },
+    { id: 'provider-startup', files: ['test/codex-app-server-discovery.test.js', 'test/session-supervision.test.js',
+      'test/progressive-discovery.test.js', 'test/desktop-record-index.test.js', 'test/desktop-background-performance.test.js'] },
     { id: 'handoff-and-audit-recovery', files: ['test/consistency-handoff.test.js', 'test/consistency-monitor.test.js', 'test/consistency-auditor.test.js', 'test/desktop-host.test.js'] },
     { id: 'migration-and-current-outcomes', files: ['test/autonomous-upgrade.test.js', 'test/local-delivery-runtime.test.js', 'test/delivery-migration-crash.test.js', 'test/purpose-inspection.test.js', 'test/purpose-search-scenarios.test.js', 'test/sqm-large-diff.test.js'] },
   ],

package/src/update-connection.js

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { normalizeWebOrigin } from './web-origin.js';
+
+// Pin the resolved settings directory and origin, not a parent shell's defaults.
+// Session/remote-host files stay in that directory across runtime replacements.
+export function updateConnectionEnvironment({ env = process.env, root, webOrigin }) {
+  if (typeof root !== 'string' || !root.trim()) throw new Error('SIMY state directory is required for an update.');
+  return { ...env, SIMY_HOME: path.resolve(root), SIMY_WEB_ORIGIN: normalizeWebOrigin(webOrigin) };
+}
+
+export function sameUpdateIdentity(expected, actual) {
+  if (expected?.auth?.state !== 'signed_in') return actual?.auth?.state !== 'signed_in';
+  return actual?.auth?.state === 'signed_in' && Boolean(expected.auth.userId) &&
+    actual.auth.userId === expected.auth.userId &&
+    (expected.access?.organizationId || null) === (actual.access?.organizationId || null);
+}