@awak-app/simy-cli 0.7.32 → 0.7.33

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/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);
+}