@awak-app/simy-cli 0.7.23 → 0.7.26

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', '依存条件待ち', '条件が変わるまで待機します。');

package/src/sqm/bundle-store.js

@@ -1,3 +1,4 @@
+import { recordSqmConnectionObservation } from '../connection-overview.js';
 import { ADVISORY_GUIDANCE_CAPABILITY, isAdvisoryGuidance } from './advisory-guidance.js';
 import { safeSqmDiagnostic } from "./diagnostics.js";
 import { createHash, createPublicKey } from "node:crypto";
@@ -25,13 +26,40 @@ export class SqmIncompatibleCliError extends Error {
 }
 
 export async function loadKnowledgeBundle({
-  repository,
-  cliVersion,
   endpoint = process.env.SIMY_SQM_BUNDLE_URL,
   token = process.env.SIMY_SQM_TOKEN || process.env.SIMY_ACCESS_TOKEN,
   accountId = process.env.SIMY_SQM_ACCOUNT_ID || (token ? `token:${createHash("sha256").update(token).digest("hex")}` : "anonymous"),
   organizationId = process.env.SIMY_SQM_ORGANIZATION_ID,
   cacheRoot = process.env.SIMY_SQM_CACHE_DIR || path.join(process.env.SIMY_HOME?.trim() || path.join(homedir(), ".simy"), "sqm"),
+  ...options
+}) {
+  const context = { ...options, endpoint, token, accountId, organizationId, cacheRoot };
+  const observe = async result => {
+    if (options.offline || !endpoint || !accountId || !organizationId) return;
+    try { await recordSqmConnectionObservation(context, result, { root: cacheRoot, now: options.now }); }
+    catch { /* Display metadata must not change SQM behavior. */ }
+  };
+  try {
+    const result = await loadKnowledgeBundleImpl(context);
+    // An online fallback retains usable knowledge, but does not confirm the
+    // current connection. Offline/cache-only reads never refresh this record.
+    await observe(result.source === 'stale_cache' ? { source: 'unavailable' } : result);
+    return result;
+  } catch (error) {
+    // Cancellation is an intentional stop, not a failed connection attempt.
+    if (!options.signal?.aborted) await observe({ source: 'unavailable' });
+    throw error;
+  }
+}
+
+async function loadKnowledgeBundleImpl({
+  repository,
+  cliVersion,
+  endpoint,
+  token,
+  accountId,
+  organizationId,
+  cacheRoot,
   ttlMs = numberEnv("SIMY_SQM_CACHE_TTL_MS", DEFAULT_TTL_MS),
   offline = false,
   refresh = false,

package/src/sqm/provider-plugin-status.js

@@ -1,9 +1,22 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { resolveBackendExecutable } from '../backend-executable.js';
 import { runProviderCommand } from './provider-command.js';
 import { CLAUDE_PLUGIN_SELECTOR } from './claude-plugin.js';
 
+// The managed marketplace selects the inventory scope, never installation or
+// enablement evidence. Those still come from the provider's actual response.
+async function managedCodexMarketplace({ home, signal }) {
+  try {
+    const bytes = await readFile(join(home, '.agents', 'plugins', 'marketplace.json'), { encoding: 'utf8', signal });
+    if (Buffer.byteLength(bytes) > 64 * 1024) return null;
+    const manifest = JSON.parse(bytes);
+    return /^[A-Za-z0-9_-]+$/.test(manifest?.name || '') && Array.isArray(manifest.plugins) &&
+      manifest.plugins.some(entry => entry?.name === 'simy') ? manifest.name : null;
+  } catch { return null; }
+}
+
 export const unavailablePluginStatus = () => ({ state: 'unknown', installed: null, enabled: null });
 
 // Provider inventories describe the actual installation and enablement. Managed
@@ -15,7 +28,7 @@ export async function inspectProviderPlugins({ home = homedir(),
   claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
   resolveExecutable = resolveBackendExecutable, run = runProviderCommand,
   timeoutMs = 5_000, signal, providers = ['codex', 'claude'], details = false,
-  onDiagnostic = () => {},
+  onDiagnostic = () => {}, readCodexMarketplace = managedCodexMarketplace,
 } = {}) {
   if (providers.some(provider => !['codex', 'claude'].includes(provider))) throw new Error('Unsupported provider.');
   const inspect = async provider => {
@@ -30,7 +43,12 @@ export async function inspectProviderPlugins({ home = homedir(),
       const executable = await resolveExecutable(provider, { signal, timeoutMs });
       if (signal?.aborted) return unavailable('cancelled');
       if (!executable) return unavailable('cli_missing');
-      const { stdout } = await run(executable, ['plugin', 'list', '--json'], {
+      const marketplace = provider === 'codex' ? await readCodexMarketplace({ home, signal }) : null;
+      if (signal?.aborted) return unavailable('cancelled');
+      // A global inventory may contact unrelated remote marketplaces. Query the
+      // configured SIMY source so their network delays cannot hide local state.
+      const args = ['plugin', 'list', '--json', ...(marketplace ? ['--marketplace', marketplace] : [])];
+      const { stdout } = await run(executable, args, {
         timeout: timeoutMs, maxBuffer: 1024 * 1024, signal, cwd: home,
         env: { ...process.env, HOME: home,
           ...(provider === 'codex' ? { CODEX_HOME: codexHome } : { CLAUDE_CONFIG_DIR: claudeHome }) },
@@ -39,7 +57,7 @@ export async function inspectProviderPlugins({ home = homedir(),
       const entries = provider === 'codex' ? payload?.installed : payload;
       if (!Array.isArray(entries)) return unavailable('invalid_inventory');
       const matches = entries.filter(entry => provider === 'codex'
-        ? typeof entry?.pluginId === 'string' && /^simy@[A-Za-z0-9_-]+$/.test(entry.pluginId)
+        ? typeof entry?.pluginId === 'string' && /^simy@[A-Za-z0-9_-]+$/.test(entry.pluginId) && (!marketplace || entry.pluginId === `simy@${marketplace}`)
         : entry?.id === CLAUDE_PLUGIN_SELECTOR);
       // Prefer the account installation; report a project-only install explicitly
       // rather than silently treating it as an installation for every project.

package/src/web-origin.js

@@ -44,3 +44,10 @@ export function isRequestOriginAllowed(requestOrigin, webOrigin) {
     return false;
   }
 }
+
+// Explicitly retain the resolved host when a command is copied to a fresh shell.
+export function daemonRestartCommand(webOrigin) {
+  const origin = resolveWebOrigin(webOrigin);
+  const quotedOrigin = '"' + origin.replace(/["\\$`]/g, "\\$&") + '"';
+  return `simy --daemon --host ${quotedOrigin}`;
+}