@awak-app/simy-cli 0.7.20 → 0.7.22

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/sqm/agent-skill.js

@@ -100,14 +100,16 @@ export async function inspectSqmAgentSkill({ home = homedir() } = {}) {
   };
 }
 
-export async function installSqmAgentSkill({ home = homedir(), platforms = Object.keys(TARGETS) } = {}) {
+export async function installSqmAgentSkill({ home = homedir(), platforms = Object.keys(TARGETS), migrateLegacyGate = true } = {}) {
   const requested = [...new Set(platforms)];
   if (!requested.length || requested.some((platform) => !Object.hasOwn(TARGETS, platform))) {
     throw new Error("platforms must contain codex and/or claude");
   }
   if (requested.includes("codex")) await installCodexPlugin({ home });
   if (requested.includes("claude")) await installClaudePlugin({ home });
-  await retireLegacySqmGate({ home });
+  // Explicit single-provider repair must not migrate another provider's hooks.
+  // Ordinary setup and workflow updates retain the existing migration behavior.
+  if (migrateLegacyGate) await retireLegacySqmGate({ home });
   for (const platform of requested) {
     await atomicText(path.join(home, ...TARGETS[platform]), SKILL_CONTENT, 0o600);
   }

package/src/sqm/provider-command.js

@@ -16,7 +16,7 @@ export function runProviderCommand(command, args, { env, cwd, timeout = 10_000,
     };
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
-      finish(new Error("Provider plugin command timed out."));
+      finish(Object.assign(new Error("Provider plugin command timed out."), { code: 'provider_timeout' }));
     }, timeout);
     timer.unref?.();
     const capture = (stream, append) => {

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

@@ -0,0 +1,105 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, realpath, rm } from 'node:fs/promises';
+import { resolveBackendExecutable } from '../backend-executable.js';
+import { inspectProviderPlugins } from './provider-plugin-status.js';
+import { runProviderCommand } from './provider-command.js';
+import { inspectSqmAgentSkill, installSqmAgentSkill } from './agent-skill.js';
+import { CLAUDE_MARKETPLACE, CLAUDE_PLUGIN_SELECTOR } from './claude-plugin.js';
+
+const fail = reason => Object.assign(new Error('SIMY plugin repair could not be verified.'), { code: 'plugin_repair_failed', reason });
+
+// Explicit user action only. Repair one provider, under the same lock as the
+// background workflow updater. Never change SIMY consent, login or hook trust.
+export async function repairProviderPlugin({ provider, home = homedir(),
+  codexHome = process.env.CODEX_HOME || join(home, '.codex'),
+  claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
+  signal, authorize = async () => {}, onDiagnostic = () => {},
+  inspect = inspectProviderPlugins, inspectSources = inspectSqmAgentSkill,
+  prepare = installSqmAgentSkill, resolveExecutable = resolveBackendExecutable,
+  run = runProviderCommand,
+} = {}) {
+  if (!['codex', 'claude'].includes(provider)) throw fail('unsupported_provider');
+  const startedAt = Date.now();
+  const check = async () => {
+    if (signal?.aborted) throw fail('cancelled');
+    await authorize();
+    if (signal?.aborted) throw fail('cancelled');
+  };
+  const options = { home, codexHome, claudeHome, providers: [provider], details: true,
+    timeoutMs: 20_000, signal, onDiagnostic, resolveExecutable, run };
+  const inventory = async () => (await inspect(options))[provider];
+  const command = async args => {
+    await check();
+    const executable = await resolveExecutable(provider, { signal, timeoutMs: 5_000 });
+    if (!executable) throw fail('cli_missing');
+    return run(executable, args, { cwd: home, signal, timeout: 20_000, maxBuffer: 1024 * 1024,
+      env: { ...process.env, HOME: home, ...(provider === 'codex' ? { CODEX_HOME: codexHome } : { CLAUDE_CONFIG_DIR: claudeHome }) } });
+  };
+  let locked = false;
+  const lock = join(home, '.simy', 'integrations', 'workflow-update.lock');
+  try {
+    await check();
+    let current = await inventory();
+    if (current?.state === 'enabled') return { state: 'repaired', plugin: current };
+    if (!['missing', 'disabled'].includes(current?.state)) throw fail(current?.reason || 'verification_failed');
+    if (provider === 'claude' && current.scope && current.scope !== 'user') throw fail('scope_requires_attention');
+    await mkdir(join(home, '.simy', 'integrations'), { recursive: true });
+    try { await mkdir(lock); locked = true; }
+    catch (error) { if (error.code === 'EEXIST') throw fail('busy'); throw error; }
+    await check();
+    // Reinspect after obtaining the lock; another updater may have finished.
+    current = await inventory();
+    if (current?.state === 'enabled') return { state: 'repaired', plugin: current };
+    if (!['missing', 'disabled'].includes(current?.state)) throw fail(current?.reason || 'verification_failed');
+    if (provider === 'claude' && current.scope && current.scope !== 'user') throw fail('scope_requires_attention');
+    let sources = await inspectSources({ home });
+    if (provider === 'codex' && current.state === 'disabled') {
+      const payload = JSON.parse((await command(['plugin', 'list', '--json'])).stdout);
+      const entry = payload.installed?.find(item => item.pluginId === current.selector);
+      if (entry?.source?.source !== 'local' || !entry.source.path ||
+          await realpath(entry.source.path) !== await realpath(sources.codex_plugin.path)) throw fail('source_conflict');
+      const marketplace = JSON.parse(await readFile(sources.codex_plugin.marketplace_path, 'utf8'));
+      if (current.selector !== `simy@${marketplace.name}`) throw fail('source_conflict');
+    }
+    if (provider === 'claude') {
+      const marketplaces = JSON.parse((await command(['plugin', 'marketplace', 'list', '--json'])).stdout);
+      if (!Array.isArray(marketplaces)) throw fail('invalid_inventory');
+      const existing = marketplaces.find(item => item.name === CLAUDE_MARKETPLACE);
+      if (existing && (existing.source !== 'directory' || !existing.path ||
+          await realpath(existing.path) !== await realpath(sources.claude_plugin.marketplace_root))) throw fail('source_conflict');
+    }
+    await check();
+    sources = await prepare({ home, platforms: [provider], migrateLegacyGate: false });
+    if (provider === 'codex') {
+      const marketplace = JSON.parse(await readFile(sources.codex_plugin.marketplace_path, 'utf8'));
+      if (!/^[A-Za-z0-9_-]+$/.test(marketplace.name || '')) throw fail('source_conflict');
+      const selector = `simy@${marketplace.name}`;
+      if (current.selector && current.selector !== selector) throw fail('source_conflict');
+      await command(['plugin', 'add', selector, '--json']);
+    } else {
+      // The managed marketplace installer preserves unrelated provider settings.
+      const marketplaces = JSON.parse((await command(['plugin', 'marketplace', 'list', '--json'])).stdout);
+      if (!Array.isArray(marketplaces)) throw fail('invalid_inventory');
+      const existing = marketplaces.find(item => item.name === CLAUDE_MARKETPLACE);
+      if (existing && (existing.source !== 'directory' || !existing.path ||
+          await realpath(existing.path) !== await realpath(sources.claude_plugin.marketplace_root))) throw fail('source_conflict');
+      if (!existing) {
+        await command(['plugin', 'marketplace', 'add', sources.claude_plugin.marketplace_root]);
+      }
+      await command(['plugin', current.state === 'missing' ? 'install' : 'enable', CLAUDE_PLUGIN_SELECTOR, '--scope', 'user']);
+    }
+    await check();
+    const verified = await inventory();
+    if (verified?.state !== 'enabled') throw fail(verified?.reason || 'verification_failed');
+    return { state: 'repaired', plugin: verified };
+  } catch (error) {
+    const reason = error?.reason || (signal?.aborted ? 'cancelled' : error?.code === 'provider_timeout' ? 'timeout' :
+      error instanceof SyntaxError ? 'invalid_inventory' :
+      ['EACCES', 'EPERM', 'EROFS'].includes(error?.code) ? 'permission_denied' : 'command_failed');
+    onDiagnostic({ provider, reason, elapsedMs: Date.now() - startedAt });
+    throw fail(reason);
+  } finally {
+    if (locked) await rm(lock, { recursive: true, force: true });
+  }
+}

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

@@ -14,13 +14,22 @@ export async function inspectProviderPlugins({ home = homedir(),
   codexHome = process.env.CODEX_HOME || join(home, '.codex'),
   claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
   resolveExecutable = resolveBackendExecutable, run = runProviderCommand,
-  timeoutMs = 5_000, signal,
+  timeoutMs = 5_000, signal, providers = ['codex', 'claude'], details = false,
+  onDiagnostic = () => {},
 } = {}) {
+  if (providers.some(provider => !['codex', 'claude'].includes(provider))) throw new Error('Unsupported provider.');
   const inspect = async provider => {
+    const startedAt = Date.now();
+    const unavailable = reason => {
+      const elapsedMs = Date.now() - startedAt;
+      onDiagnostic({ provider, reason, elapsedMs });
+      return { ...unavailablePluginStatus(), ...(details ? { reason, elapsedMs } : {}) };
+    };
     try {
-      if (signal?.aborted) return unavailablePluginStatus();
+      if (signal?.aborted) return unavailable('cancelled');
       const executable = await resolveExecutable(provider, { signal, timeoutMs });
-      if (!executable || signal?.aborted) return unavailablePluginStatus();
+      if (signal?.aborted) return unavailable('cancelled');
+      if (!executable) return unavailable('cli_missing');
       const { stdout } = await run(executable, ['plugin', 'list', '--json'], {
         timeout: timeoutMs, maxBuffer: 1024 * 1024, signal, cwd: home,
         env: { ...process.env, HOME: home,
@@ -28,7 +37,7 @@ export async function inspectProviderPlugins({ home = homedir(),
       });
       const payload = JSON.parse(stdout);
       const entries = provider === 'codex' ? payload?.installed : payload;
-      if (!Array.isArray(entries)) return unavailablePluginStatus();
+      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)
         : entry?.id === CLAUDE_PLUGIN_SELECTOR);
@@ -42,11 +51,14 @@ export async function inspectProviderPlugins({ home = homedir(),
       const entry = matches[0];
       if (!entry || provider === 'codex' && entry.installed === false) return { state: 'missing', installed: false, enabled: false };
       if (typeof entry.enabled !== 'boolean' || provider === 'codex' && entry.installed !== true ||
-        provider === 'claude' && !scopes.includes(entry.scope)) return unavailablePluginStatus();
+        provider === 'claude' && !scopes.includes(entry.scope)) return unavailable('invalid_inventory');
       return { state: entry.enabled ? 'enabled' : 'disabled', installed: true, enabled: entry.enabled,
+        ...(details ? { selector: provider === 'codex' ? entry.pluginId : entry.id } : {}),
         ...(provider === 'claude' ? { scope: entry.scope, enablementContext: 'home' } : {}) };
-    } catch { return unavailablePluginStatus(); }
+    } catch (error) {
+      return unavailable(signal?.aborted ? 'cancelled' : error?.code === 'provider_timeout' ? 'timeout' :
+        error instanceof SyntaxError ? 'invalid_inventory' : 'command_failed');
+    }
   };
-  const [codex, claude] = await Promise.all([inspect('codex'), inspect('claude')]);
-  return { codex, claude };
+  return Object.fromEntries(await Promise.all(providers.map(async provider => [provider, await inspect(provider)])));
 }