@awak-app/simy-cli 0.7.19 → 0.7.21

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

@@ -1,57 +1,112 @@
+import { readRemoteSessionLists } from './remote-session-list.js';
 import { hostname } from 'node:os';
 import { stripVTControlCharacters } from 'node:util';
 import { readProviderLinks } from '../provider-links.js';
 import { openCodexAppServer, listCodexSessions } from './codex-app-server.js';
+import { listClaudeSessions } from './claude-sessions.js';
 import { readCodexTitles } from './session-titles.js';
 import { sessionWorkState } from './work-state.js';
 
 export const terminalText = value => stripVTControlCharacters(String(value ?? '')).replace(/[\x00-\x1f\x7f-\x9f]/g, ' ').trim();
 export function filterSessionList(sessions, query = '') {
   const needle = query.trim().toLocaleLowerCase();
-  return sessions.filter(row => !needle || [row.title, row.session, row.cwd].some(value => String(value || '').toLocaleLowerCase().includes(needle)));
+  return sessions.filter(row => !needle || [row.title, row.session, row.cwd, row.provider, row.hostLabel].some(value => String(value || '').toLocaleLowerCase().includes(needle)));
 }
 
 // List directly from the installed local provider. No agent, supervisor,
 // enrollment, archive reconciliation or provider turn is started by this view.
-export async function readLocalSessionList({ root, signal, includeArchived = false,
-  openClient = openCodexAppServer, readLinks = readProviderLinks, readTitles = readCodexTitles } = {}) {
+export async function readLocalSessionList({ root, signal, includeArchived = false, provider = 'all',
+  openClient = openCodexAppServer, listClaude = listClaudeSessions,
+  readLinks = readProviderLinks, readTitles = readCodexTitles } = {}) {
   const links = await readLinks(root);
-  if (!links.codex.connected) throw Object.assign(new Error('Codex is disconnected from SIMY. Reconnect it before listing conversations.'), { code: 'provider_link_disconnected' });
-  const client = await openClient({ signal, cancelOnAbort: true });
-  let sessions;
-  try {
-    sessions = await listCodexSessions({ client, inspectState: true });
-    if (includeArchived) sessions.push(...(await listCodexSessions({ client, archived: true })).map(row => ({ ...row, archived: true })));
-  } finally { await client.close(); }
-  const titles = await readTitles();
+  const providers = ['codex', 'claude'].filter(name => links[name]?.connected && (provider === 'all' || name === provider));
+  if (!providers.length) throw Object.assign(new Error('Codex and Claude Code are disconnected from SIMY. Reconnect a provider before listing conversations.'), { code: 'provider_link_disconnected' });
+  const results = await Promise.allSettled(providers.map(async provider => {
+    signal?.throwIfAborted();
+    if (provider === 'claude') return (await listClaude({ all: true, signal })).filter(row => includeArchived || !row.archived);
+    const client = await openClient({ signal, cancelOnAbort: true });
+    let sessions;
+    try {
+      sessions = await listCodexSessions({ client, all: true, signal, inspectState: true });
+      if (includeArchived) sessions.push(...(await listCodexSessions({ client, all: true, signal, archived: true })).map(row => ({ ...row, archived: true })));
+    } finally { await client.close(); }
+    const titles = await readTitles();
+    return sessions.map(row => ({ ...row, title: row.title || titles.get(row.session) }));
+  }));
   signal?.throwIfAborted();
   const currentLinks = await readLinks(root);
-  if (!currentLinks.codex.connected || currentLinks.codex.epoch !== links.codex.epoch) throw Object.assign(new Error('Codex connection changed. Refresh the conversation list.'), { code: 'provider_link_changed' });
-  return { host: hostname(), observedAt: new Date().toISOString(), sessions: [...new Map(sessions.map(row => [row.session, row])).values()].map(row => ({
-    provider: 'codex', session: row.session, title: terminalText(row.title || titles.get(row.session) || row.session),
-    cwd: terminalText(row.cwd), archived: row.archived === true,
-    workState: sessionWorkState(row),
-  })) };
+  for (const provider of providers) {
+    if (!currentLinks[provider]?.connected || currentLinks[provider].epoch !== links[provider].epoch)
+      throw Object.assign(new Error('Provider connection changed. Refresh the conversation list.'), { code: 'provider_link_changed' });
+  }
+  if (results.every(result => result.status === 'rejected')) throw results[0].reason;
+  const warnings = results.flatMap((result, index) => result.status === 'rejected'
+    ? [`${providers[index]}: ${terminalText(result.reason?.message || 'Conversation discovery unavailable')}`] : []);
+  const sessions = results.flatMap(result => result.status === 'fulfilled' ? result.value : []);
+  return { host: hostname(), observedAt: new Date().toISOString(), complete: warnings.length === 0, warnings,
+    sessions: [...new Map(sessions.map(row => [`${row.provider}:${row.session}`, row])).values()]
+      .sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || a.provider.localeCompare(b.provider) || a.session.localeCompare(b.session))
+      .map(row => ({
+        provider: row.provider, session: row.session, title: terminalText(row.title || row.session),
+        cwd: terminalText(row.cwd), archived: row.archived === true,
+        workState: sessionWorkState(row),
+      })) };
 }
+// Aggregate only explicitly registered hosts, preserving the host/provider/ID tuple.
+export async function readSessionList({ root, signal, provider = 'all', localOnly = false, includeArchived = false,
+  readLinks = readProviderLinks, loadLocal = readLocalSessionList, loadRemote = readRemoteSessionLists } = {}) {
+  const links = await readLinks(root);
+  const providers = ['codex', 'claude'].filter(name => links[name]?.connected && (provider === 'all' || name === provider));
+  if (!providers.length) throw Object.assign(new Error('Reconnect a provider before listing conversations.'), { code: 'provider_link_disconnected' });
+  const [local, remote] = await Promise.allSettled([
+    loadLocal({ root, signal, provider, includeArchived, readLinks }),
+    localOnly ? [] : loadRemote({ root, signal, providers, includeArchived }),
+  ]);
+  signal?.throwIfAborted();
+  const current = await readLinks(root);
+  for (const name of providers) if (!current[name]?.connected || current[name].epoch !== links[name].epoch)
+    throw Object.assign(new Error('Provider connection changed. Refresh the conversation list.'), { code: 'provider_link_changed' });
+  const warnings = [], sessions = [], hosts = [];
+  if (local.status === 'fulfilled') {
+    sessions.push(...local.value.sessions.map(row => ({ ...row, hostId: 'local', hostLabel: local.value.host })));
+    warnings.push(...(local.value.warnings || []));
+  } else warnings.push(`local: ${terminalText(local.reason?.message)}`);
+  if (remote.status === 'rejected') warnings.push(`remote: ${terminalText(remote.reason?.message)}`);
+  else for (const result of remote.value) {
+    hosts.push({ id: result.host.id, label: result.host.label, state: result.error ? 'unavailable' : 'ready' });
+    if (result.error) { warnings.push(`${result.host.label}: ${terminalText(result.error)}`); continue; }
+    warnings.push(...(result.catalog.warnings || []).map(warning => `${result.host.label}: ${terminalText(warning)}`));
+    if (result.catalog.complete === false && !result.catalog.warnings?.length) warnings.push(`${result.host.label}: incomplete catalog`);
+    sessions.push(...result.catalog.sessions.map(row => ({
+      provider: row.provider, session: row.session, title: terminalText(row.title || row.session), cwd: terminalText(row.cwd),
+      archived: row.archived === true, hostId: result.host.id, hostLabel: result.host.label,
+      workState: { label: terminalText(row.workState?.label || '状態未確認') },
+    })));
+  }
+  return { host: hostname(), observedAt: new Date().toISOString(), complete: warnings.length === 0, warnings, hosts,
+    sessions: [...new Map(sessions.map(row => [`${row.hostId}:${row.provider}:${row.session}`, row])).values()] };
+}
+
 export function formatSessionList(catalog, query = '') {
   const rows = filterSessionList(catalog.sessions, query);
-  return [`SIMY · Codex会話一覧 · ${terminalText(catalog.host)}`,
+  return [`SIMY · Codex / Claude Code 会話一覧 · ${terminalText(catalog.host)}`,
     `表示 ${rows.length} / ${catalog.sessions.length} 件${query ? ` · 検索: ${terminalText(query)}` : ''}`,
+    ...(catalog.warnings || []).map(warning => `取得未完了: ${terminalText(warning)}`),
     ...rows.flatMap((row, index) => [
       `${index + 1}. ${terminalText(row.title)}`,
-      `   ${terminalText(row.workState?.label || '状態未確認')} · ${row.session}`,
+      `   ${terminalText(row.hostLabel || catalog.host)} · ${row.provider === 'claude' ? 'Claude Code' : 'Codex'} · ${terminalText(row.workState?.label || '状態未確認')} · ${row.session}`,
       `   ${terminalText(row.cwd)}`,
     ]), ...(rows.length ? [] : ['一致する会話はありません。'])].join('\n') + '\n';
 }
 
 export async function runSessionListCommand(argv, { output = process.stdout, errors = process.stderr, input = process.stdin,
-  load = readLocalSessionList, renderInteractive } = {}) {
-  let query = '', json = false, interactive = false, includeArchived = false;
+  load = readSessionList, renderInteractive } = {}) {
+  let query = '', json = false, interactive = false, includeArchived = false, localOnly = false, provider = 'all';
   try {
     for (let i = 0; i < argv.length; i++) {
       const arg = argv[i];
       if (arg === '--help' || arg === '-h') {
-        output.write('simy sessions [--query TEXT] [--json | --interactive] [--include-archived]\n\nShow local Codex conversations. No task is started or resumed.\n'); return 0;
+        output.write('simy sessions [--query TEXT] [--json | --interactive] [--include-archived] [--local-only] [--provider all|codex|claude]\n\nShow available Codex and Claude Code conversations on this host and registered SSH hosts. No task is started or resumed.\n'); return 0;
       }
       if (arg === '--query') {
         if (typeof argv[i + 1] !== 'string' || argv[i + 1].startsWith('--')) throw new Error('--query requires search text.');
@@ -59,6 +114,11 @@ export async function runSessionListCommand(argv, { output = process.stdout, err
       } else if (arg === '--json') json = true;
       else if (arg === '--interactive') interactive = true;
       else if (arg === '--include-archived') includeArchived = true;
+      else if (arg === '--local-only') localOnly = true;
+      else if (arg === '--provider') {
+        provider = argv[++i];
+        if (!['all', 'codex', 'claude'].includes(provider)) throw new Error('--provider requires all, codex or claude.');
+      }
       else throw new Error(`Unknown sessions option: ${terminalText(arg)}`);
     }
     if (json && interactive) throw new Error('Choose --json or --interactive.');
@@ -67,7 +127,7 @@ export async function runSessionListCommand(argv, { output = process.stdout, err
     const cancel = () => controller.abort();
     process.once('SIGINT', cancel); process.once('SIGTERM', cancel);
     try {
-      const refresh = () => load({ includeArchived, signal: controller.signal });
+      const refresh = () => load({ includeArchived, localOnly, provider, signal: controller.signal });
       const catalog = await refresh();
       if (interactive) {
         const start = renderInteractive || (await import('../console/sessions.js')).runSessionListConsole;

package/src/update-detachment/runtime.js

@@ -259,18 +259,22 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
   };
   return {bind,boundary,reconcile,store,gate:adapters.gate,
     async initialize() {if(!transaction)write({connectionState:readDispatchGate(root).connection,phase:'startup',updateState:'pending'});},
-    snapshot(base,update) {
+    snapshot(base,update,{accessReady=true}={}) {
       if(ownerTransferred)transaction=readState(file);
       const action=base.state==='connected' && update?.state==='waiting_for_idle'?'detach_update':base.state==='detaching'?'cancel_detach_update':!base.busy && ['detached','recovery_required'].includes(base.state)?'update_reconnect':null;
       const frame={...base,schemaVersion:1,connectionState:base.state,
-        updateState:transaction?.updateState || 'pending',tasks:rows(),actions:action?[action]:[]};
+        updateState:transaction?.updateState || 'pending',updaterState:update?.state || 'unknown',tasks:rows(),actions:action?[action]:[]};
+      // Revision the exact frame the native client sees. Filtering after the
+      // fingerprint makes an access change look like conflicting data at the
+      // same revision, which correctly fences all native update actions.
+      if(!accessReady) {frame.tasks=[];frame.actions=frame.actions.filter(action=>action==='cancel_detach_update');}
       const fingerprint=digest(frame);
       if(!ownerTransferred && transaction && transaction.presentation!==fingerprint)write({presentation:fingerprint});
       presented={...frame,operationId:transaction?.operationId,revision:transaction?.revision || 0};
       return presented;
     },
-    validate(command,base,update) {
-      const frame=this.snapshot(base,update);
+    validate(command,base,update,options) {
+      const frame=this.snapshot(base,update,options);
       if(command.operationId!==frame.operationId || command.revision!==frame.revision || !frame.actions.includes(command.action) || transaction?.claimedCommands?.includes(command.id))throw failure('stale_operation');
       write({claimedCommands:[...(transaction?.claimedCommands || []).slice(-255),command.id]});
     },