@awak-app/simy-cli 0.7.25 → 0.7.26

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

@@ -24,7 +24,8 @@ function normalizedHost(value) {
   if (!value || typeof value.alias !== 'string' || !aliasPattern.test(value.alias)) throw error('Enter an SSH host alias, for example nvidia-workstation.', 'remote_host_invalid');
   const label = typeof value.label === 'string' ? value.label.trim() : '';
   if (label.length > 80 || /[\x00-\x1f\x7f]/.test(label)) throw error('Choose a shorter host name.', 'remote_host_invalid');
-  return { alias: value.alias, label: label || value.alias, id: remoteHostId(value.alias) };
+  if (value.enabled !== undefined && typeof value.enabled !== 'boolean') throw error('Invalid connection preference.', 'remote_host_invalid');
+  return { alias: value.alias, label: label || value.alias, id: remoteHostId(value.alias), ...(value.enabled === false ? { enabled: false } : {}) };
 }
 export async function readHosts(root) {
   let value;
@@ -67,7 +68,7 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
     }
   }
   function connect(connection) {
-    if (closed || connection.child || now() < connection.retryAt) return;
+    if (closed || connection.enabled === false || connection.child || now() < connection.retryAt) return;
     connection.state = 'connecting'; connection.reason = null;
     let child;
     try { child = spawnImpl('ssh', ['-T', '-o', 'BatchMode=yes', '-o', 'StrictHostKeyChecking=yes', '-o', 'ConnectTimeout=5',
@@ -144,52 +145,102 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
     for (const host of hosts) {
       let c = connections.get(host.id);
       if (!c) { c = { ...host, pending: new Map(), retryAt: 0, ready: false, status: null }; connections.set(host.id, c); }
-      c.label = host.label;
+      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;
+        continue;
+      }
+      if (c.state === 'disconnected') c.retryAt = 0;
       if (c.ready && now() - c.receivedAt > 45_000) disconnect(c, 'Remote status is stale. Reconnecting.');
       connect(c);
     }
   }
-  async function save(value, remove = false) {
-    const host = normalizedHost(value);
+  async function persistHosts(change, apply) {
     const work = writes.catch(() => {}).then(async () => {
-      const hosts = (await readHosts(root)).filter(h => h.id !== host.id);
-      if (!remove) hosts.push(host);
+      const hosts = await change(await readHosts(root));
       if (hosts.length > MAX_HOSTS) throw error('At most eight remote hosts can be connected.', 'remote_host_invalid');
       await mkdir(root, { recursive: true, mode: 0o700 });
       const path = join(root, 'remote-hosts.json'), temporary = `${path}.${randomUUID()}.tmp`;
       try { await writeFile(temporary, JSON.stringify({ schemaVersion: 1, hosts }) + '\n', { mode: 0o600 }); await rename(temporary, path); }
       finally { await rm(temporary, { force: true }); }
-      generation++;
-      const c = connections.get(host.id);
-      if (c) { disconnect(c); if (remove) connections.delete(host.id); else c.retryAt = 0; }
-      changed();
+      generation++; apply(); changed();
     });
     writes = work; await work;
   }
+  async function save(value, remove = false) {
+    const host = normalizedHost(value);
+    await persistHosts(hosts => [...hosts.filter(h => h.id !== host.id), ...(remove ? [] : [host])], () => {
+      const c = connections.get(host.id);
+      if (c) { disconnect(c); if (remove) connections.delete(host.id); else { c.enabled = host.enabled !== false; c.retryAt = 0; } }
+    });
+  }
+  async function edit(value) {
+    const previous = normalizedHost({ alias: value.previousAlias });
+    const next = normalizedHost(value);
+    await persistHosts(hosts => {
+      const existing = hosts.find(h => h.id === previous.id);
+      if (!existing) throw error('This device is no longer registered. Refresh the device list.', 'remote_host_invalid');
+      if (next.id !== previous.id && hosts.some(h => h.id === next.id)) throw error('That SSH host is already registered.', 'remote_host_invalid');
+      return hosts.map(h => h.id === previous.id ? { ...next, ...(existing.enabled === false ? { enabled: false } : {}) } : h);
+    }, () => {
+      const c = connections.get(previous.id);
+      if (!c) return;
+      if (next.id === previous.id) c.label = next.label;
+      else { disconnect(c); connections.delete(previous.id); }
+    });
+  }
+  async function setEnabled(alias, enabled) {
+    const host = normalizedHost({ alias });
+    if (typeof enabled !== 'boolean') throw error('Invalid connection preference.', 'remote_host_invalid');
+    await persistHosts(hosts => {
+      if (!hosts.some(h => h.id === host.id)) throw error('This device is no longer registered. Refresh the device list.', 'remote_host_invalid');
+      return hosts.map(h => h.id === host.id ? normalizedHost({ ...h, enabled }) : h);
+    }, () => {
+      const c = connections.get(host.id);
+      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'; }
+    });
+  }
   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');
     if (status.providerLinks?.[command.provider]?.connected === false) throw error('Provider is disconnected.', 'remote_host_access');
     const c = connections.get(command.hostId);
     if (!c?.ready || !c.child || now() - c.receivedAt > 45_000) throw error('The remote host is disconnected. Reconnect before using this conversation.');
-    if (!allowedActions.has(command.action) || !['codex', 'claude'].includes(command.provider) || typeof command.session !== 'string' ||
-      !c.status?.sessionSupervision?.sessions?.some(s => s?.provider === command.provider && s.session === command.session)) throw error('Select an available remote conversation.', 'remote_host_invalid');
+    const manualAdd = command.action === 'session_add' && command.provider === 'codex' && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(command.session || '');
+    if ((!manualAdd && !allowedActions.has(command.action)) || !['codex', 'claude'].includes(command.provider) || typeof command.session !== 'string' ||
+      (!manualAdd && !c.status?.sessionSupervision?.sessions?.some(s => s?.provider === command.provider && s.session === command.session))) throw error('Select an available remote conversation.', 'remote_host_invalid');
+    const restoreHidden = manualAdd && c.status?.sessionSupervision?.sessions?.some(row =>
+      row.provider === command.provider && row.session === command.session && row.localHidden === true);
     const id = randomUUID();
     const { hostId, ...payload } = command;
-    return new Promise((resolve, reject) => {
+    const result = await new Promise((resolve, reject) => {
       const timer = setTimeout(() => { c.pending.delete(id); reject(error('Remote operation timed out. Check its result in the original conversation before retrying.')); }, requestTimeoutMs);
       c.pending.set(id, { id: command.id, resolve, reject, timer });
-      c.child.stdin.write(JSON.stringify({ ...payload, id }) + '\n', e => {
+      c.child.stdin.write(JSON.stringify({ ...payload, ...(manualAdd ? { action: 'session_monitor', monitor: true } : {}), id }) + '\n', e => {
         if (e && c.pending.has(id)) { c.pending.delete(id); clearTimeout(timer); reject(error('Remote command could not be delivered.')); }
       });
     });
+    // Existing remote runtimes understand these two idempotent navigation
+    // operations. Monitoring alone does not clear a remote local archive.
+    // Re-enter the normal forwarding path to recheck scope and connectivity;
+    // never restore a provider archive or resume the conversation's task.
+    if (restoreHidden && result.ok === true) return forward({ ...command, action: 'session_restore', scope: 'local' }, status);
+    return result;
   }
   function project(status, { providerLinks = status.providerLinks } = {}) {
     if (!usable(status) || scopeOf(status) !== scope) return status;
     const hosts = [...connections.values()];
-    const sessions = [], runs = [];
+    const sessions = [], runs = [], selectionCandidates = [];
     for (const c of hosts) {
       const ready = c.ready && now() - c.receivedAt <= 45_000;
       const unavailableReason = c.reason || 'Remote status is stale.';
+      if (ready) for (const row of c.status?.sessionSupervision?.selectionCandidates || c.status?.sessionSupervision?.sessions || []) {
+        if (row?.provider === 'codex' && typeof row.session === 'string') selectionCandidates.push({ provider: 'codex', session: row.session,
+          title: typeof row.title === 'string' ? row.title : '', hostId: c.id, hostLabel: c.label === c.alias ? c.label : `${c.label} (${c.alias})` });
+      }
       for (const row of c.status?.sessionSupervision?.sessions || []) {
         if (!row || !['codex', 'claude'].includes(row.provider) || typeof row.session !== 'string' ||
           providerLinks?.[row.provider]?.connected === false) continue;
@@ -212,11 +263,11 @@ export function createRemoteHostManager({ root, spawnImpl = spawn, onChange = ()
       }
       if (ready) for (const run of c.status?.deliveryHooks?.runs || []) if (['codex', 'claude'].includes(run?.provider) && providerLinks?.[run.provider]?.connected !== false) runs.push({ ...stamp(run, c), originalSessionTarget: { kind: 'manual', url: null, verifiedOnPlatform: false, reason: `Select ${c.label} in ${run.provider === 'claude' ? 'Claude Code' : 'Codex'}, then find conversation ${run.session}.` } });
     }
-    return { ...status, remoteHosts: { error: settingsError, items: hosts.map(c => ({ id: c.id, alias: c.alias, label: c.label, state: c.state, reason: c.reason })) },
-      sessionSupervision: { ...status.sessionSupervision, sessions: [...(status.sessionSupervision?.sessions || []).filter(row => !row.hostId || row.hostId === 'local'), ...sessions].sort(compareSessionWork) },
+    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, reason: c.reason })) },
+      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] } };
   }
-  return { update, save, forward, project,
+  return { update, save, edit, setEnabled, forward, project,
     hasSession: session => [...connections.values()].some(c => c.status?.sessionSupervision?.sessions?.some(s => ['codex', 'claude'].includes(s?.provider) && s.session === session)),
     async close() { closed = true; for (const c of connections.values()) disconnect(c); connections.clear(); await writes.catch(() => {}); } };
 }

package/src/session-supervision/remote-managed-delivery.js

@@ -0,0 +1,94 @@
+import { mkdir, readFile, writeFile, rename, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { isDeepStrictEqual } from 'node:util';
+
+const sessionId = value => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value);
+const actions = new Set(['delivery_resume', 'delivery_pause', 'delivery_stop']);
+
+// A host-local adapter, not an execution controller. Supply the installed
+// runtime's resumeSession/controlDelivery, record reader and status projection.
+// The existing managed supervisor remains the only owner of claims/dispatches.
+export async function createRemoteManagedDelivery({ root, stateRoot, scope, authorize, select,
+  readRecord, listRecords, resumeSession, controlDelivery, deliveryHookStatus }) {
+  const automaticRoot = join(stateRoot, 'targets');
+  const manualRoot = join(stateRoot, 'manual-targets');
+  await mkdir(automaticRoot, { recursive: true, mode: 0o700 });
+  await mkdir(manualRoot, { recursive: true, mode: 0o700 });
+  async function target(directory, session) {
+    if (!sessionId(session)) throw new Error('Select a known conversation');
+    try { return JSON.parse(await readFile(join(directory, session + '.json'), 'utf8')); }
+    catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  }
+  const read = (provider, session) => readRecord(root, provider, session);
+  const matches = (binding, record) => binding && record?.run?.id === binding.runId &&
+    record.run.managed?.taskId === binding.taskId;
+  async function guard(candidate) {
+    if (candidate?.provider !== 'codex' || !sessionId(candidate.session)) throw new Error('Select a known conversation');
+    const automatic = await target(automaticRoot, candidate.session);
+    const record = await read('codex', candidate.session);
+    if (automatic) {
+      await authorize(automatic.scope);
+      if (!record?.autoContinue || record.autoContinueEpoch !== automatic.epoch) throw new Error('Continuation consent changed');
+      return automatic;
+    }
+    const manual = await target(manualRoot, candidate.session);
+    if (!matches(manual, record)) throw new Error('Conversation not selected');
+    await authorize(manual.scope);
+    return manual;
+  }
+  async function records() {
+    const selectedScope = scope();
+    if (!selectedScope) return [];
+    const rows = new Map();
+    for (const [directory, automatic] of [[automaticRoot, true], [manualRoot, false]]) {
+      for (const file of await readdir(directory)) {
+        if (!file.endsWith('.json') || !sessionId(file.slice(0, -5))) continue;
+        const session = file.slice(0, -5), binding = await target(directory, session);
+        if (!binding || !isDeepStrictEqual(binding.scope, selectedScope)) continue;
+        const record = await read('codex', session);
+        if (automatic ? record?.autoContinue && record.autoContinueEpoch === binding.epoch : matches(binding, record))
+          rows.set(session, record);
+      }
+    }
+    return [...rows.values()];
+  }
+  async function control(command) {
+    if (!actions.has(command?.action) || command.provider !== 'codex' || !sessionId(command.session) ||
+        typeof command.taskId !== 'string' || !command.taskId) throw new Error('Unsupported remote command');
+    const selectedScope = await authorize();
+    const candidate = await select(command);
+    if (candidate?.provider !== command.provider || candidate.session !== command.session) throw new Error('Select a known conversation');
+    const automatic = await target(automaticRoot, command.session);
+    if (automatic || command.action !== 'delivery_resume') await guard(command);
+    const record = await read(command.provider, command.session);
+    if (record?.run?.managed?.taskId !== command.taskId ||
+        command.expectedRunId !== undefined && record.run.id !== command.expectedRunId)
+      throw new Error('Task changed; refresh before operating');
+    await authorize(selectedScope);
+    // Forward only the native control contract. A command cannot provide an
+    // admission, resume observation, permission override, or dispatch receipt.
+    await (command.action === 'delivery_resume' ? resumeSession : controlDelivery)({
+      root, provider: command.provider, session: command.session, taskId: command.taskId,
+      expectedRunId: command.expectedRunId ?? record.run.id, expectedRevision: command.expectedRevision,
+      action: command.action.slice('delivery_'.length),
+    });
+    if (!automatic && command.action === 'delivery_resume') {
+      await authorize(selectedScope);
+      if (!matches({ runId: record.run.id, taskId: command.taskId }, await read(command.provider, command.session)))
+        throw new Error('Task changed; refresh before operating');
+      const file = join(manualRoot, command.session + '.json');
+      const temporary = file + '.' + randomUUID() + '.tmp';
+      await writeFile(temporary, JSON.stringify({ scope: selectedScope, runId: record.run.id, taskId: command.taskId }) + '\n', { mode: 0o600 });
+      await rename(temporary, file);
+    }
+  }
+  async function status() {
+    const selectedScope = await authorize();
+    // Supplying records is essential: display must not reconcile/mutate runs.
+    const result = await deliveryHookStatus({ root, records: await listRecords(root) });
+    await authorize(selectedScope);
+    return result;
+  }
+  return { control, guard, records, status, readCurrentRecord: read };
+}

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

@@ -6,7 +6,7 @@ import { readHosts } from './remote-hosts.js';
 // This read-only command never boots a remote desktop host or supervisor.
 export async function readRemoteSessionLists({ root = process.env.SIMY_HOME?.trim() || join(homedir(), '.simy'),
   providers, includeArchived = false, signal, spawnImpl = spawn, timeoutMs = 30_000 } = {}) {
-  const hosts = await readHosts(root);
+  const hosts = (await readHosts(root)).filter(host => host.enabled !== false);
   return Promise.all(hosts.map(async host => {
     try {
       signal?.throwIfAborted();

package/src/session-supervision/statistics.js

@@ -61,7 +61,13 @@ class StatisticsAccumulator {
     if (!row || typeof row !== 'object' || Array.isArray(row)) { this.missing = true; return; }
     if (this.provider === 'codex' && row.type === 'session_meta') {
       if (row.payload?.id !== this.session) this.wrongSession = true;
-      else this.matched = true;
+      else {
+        this.matched = true;
+        // Creation can precede the first usage/activity record. Forked history
+        // can also contain older events belonging to the parent conversation.
+        const created = Date.parse(row.payload?.timestamp ?? row.timestamp);
+        if (Number.isFinite(created)) this.startedAt = created;
+      }
     }
     if (this.provider === 'claude') {
       if (row.sessionId !== this.session || row.isSidechain === true) return;
@@ -104,9 +110,10 @@ class StatisticsAccumulator {
     }
   }
   *finishSteps(now, incomplete = false, coverage = {}) {
-    if (!this.matched || this.wrongSession || this.earliest > now) return unavailableStatistics();
+    const first = this.startedAt ?? this.earliest;
+    if (!this.matched || this.wrongSession || first > now) return unavailableStatistics();
     const missing = this.missing || incomplete;
-    const start = Math.max(this.earliest, now - WINDOW_MS), end = now;
+    const start = Math.max(first, now - WINDOW_MS), end = now;
     const hours = new Map();
     for (let at = Math.floor(start / HOUR) * HOUR; at <= end; at += HOUR) hours.set(at, { at, tokens: null });
     let batch = 0;

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

@@ -28,7 +28,12 @@ export function sessionWorkState(candidate, run, { now = Date.now(), provider }
     return result('approval', '承認待ち', candidate.decisionRequest?.context || '実行する操作の確認が必要です。', 'review_approval', true);
   if (question || phase === 'needs_clarification' || candidate.analysis?.state === 'needs_user' || candidate.decisionRequest?.kind === 'question')
     return result('question', '回答待ち', candidate.decisionRequest?.question || '続けるために回答が必要です。', 'answer', true);
+  if (candidate.autoContinue === true && ['starting', 'recovering'].includes(candidate.autoContinueStatus))
+    return result(candidate.autoContinueStatus, candidate.autoContinueStatus === 'starting' ? '自動継続を準備中' : '自動復旧中',
+      candidate.autoContinueReason || '自動継続はオンで保存されています。');
   if ((run?.autoRecovery || run?.managed?.autoRecovery) && ['recovery_required', 'auto_resuming'].includes(run.state)) return result('checking', 'AIが状況確認中', '自動復旧の結果を待っています。');
+  if (candidate.autoContinue === true && candidate.autoContinueStatus === 'supervising' && run?.state === 'verification_pending')
+    return result('checking', '結果を確認中', '作業の結果を自動で確認しています。');
   if (['failed', 'recovery_required', 'budget_exhausted'].includes(run?.state) || candidate.analysis?.state === 'failed' || candidate.autoContinueStatus === 'error')
     return result('error', '対応が必要', run?.reason || '作業が中断されています。', run?.canResume || run?.canReplan ? 'resume' : 'open_original', true);
   if (run?.dependencyWait || run?.managed?.dependencyWait) return result('waiting', '依存条件待ち', '条件が変わるまで待機します。');