elanous 0.2.0 → 0.2.5

package/src/storage/storage-detect.ts

@@ -0,0 +1,337 @@
+// 클라우드 CLI 감지 — 이 기계에 무엇이 깔려 있고 누구로 로그인돼 있나.
+// 읽기 전용이다. 버킷·객체를 만들거나 지우거나 쓰지 않는다.
+// 명령 실패·시간 초과는 «로그인 안 됨»이 아니다 — signedIn: null(모름).
+
+import { accessSync, constants as fsConstants } from 'node:fs';
+import { homedir } from 'node:os';
+import { debug } from '../debug/log.js';
+import { resolveCliBin, type CliBinDeps, type CliBinName } from './cli-bin.js';
+import { resolveStorageConfig } from './object-store.js';
+
+export const STORAGE_PROVIDERS = ['local', 'gcs', 'azure', 's3', 'r2'] as const;
+export type StorageProviderId = (typeof STORAGE_PROVIDERS)[number];
+
+export interface StorageCliInfo {
+  name: string;
+  path: string | null;
+  version: string | null;
+}
+
+export interface StorageProviderDetect {
+  provider: StorageProviderId;
+  cli: StorageCliInfo;
+  signedIn: boolean | null;
+  account: string | null;
+  project: string | null;
+  bucketCount: number | null;
+  hint: string;
+}
+
+export interface StorageCommandResult {
+  code: number;
+  stdout: string;
+  stderr: string;
+  /** 시간 초과·실행 불가. 로그인 안 됨으로 단정하지 않는다. */
+  timedOut?: boolean;
+}
+
+export interface StorageDetectDeps {
+  run: (bin: string, args: string[], opts: { timeoutMs: number }) => Promise<StorageCommandResult>;
+  /** 알려진 설치 경로 → PATH. 없으면 null. */
+  which?: (name: string) => string | null;
+  /** which 를 안 줄 때 resolveCliBin 에 넘긴다. */
+  cliBin?: CliBinDeps;
+  home?: string;
+  /** Local storage root; default = `resolveStorageConfig().localDir`. */
+  localDir?: string;
+  platform?: NodeJS.Platform;
+  /** ~/.elanous/storage 쓰기 가능 여부. 없으면 실제 디렉터리를 본다. */
+  localWritable?: boolean;
+  /** 현재 storage.provider. 없으면 'local'. */
+  currentProvider?: string;
+  log?: (category: string, event: string, data?: unknown) => void;
+}
+
+const TIMEOUT_MS = 8000;
+const CLI_BIN_NAMES = new Set<string>(['gcloud', 'aws', 'az', 'wrangler']);
+
+const CLI_NAME: Record<Exclude<StorageProviderId, 'local'>, string> = {
+  gcs: 'gcloud',
+  azure: 'az',
+  s3: 'aws',
+  r2: 'wrangler',
+};
+
+function installHint(provider: StorageProviderId, platform: NodeJS.Platform): string {
+  if (provider === 'local') return '';
+  if (provider === 'gcs') {
+    if (platform === 'darwin') return 'brew install --cask google-cloud-sdk';
+    if (platform === 'win32') return 'winget install Google.CloudSDK';
+    return 'sudo snap install google-cloud-cli --classic';
+  }
+  if (provider === 'azure') {
+    if (platform === 'darwin') return 'brew install azure-cli';
+    if (platform === 'win32') return 'winget install Microsoft.AzureCLI';
+    return 'curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash';
+  }
+  if (provider === 's3') {
+    if (platform === 'darwin') return 'brew install awscli';
+    if (platform === 'win32') return 'winget install Amazon.AWSCLI';
+    return 'sudo snap install aws-cli --classic';
+  }
+  if (platform === 'darwin') return 'brew install wrangler';
+  if (platform === 'win32') return 'winget install Cloudflare.Wrangler';
+  return 'npm install -g wrangler';
+}
+
+function loginHint(provider: StorageProviderId): string {
+  if (provider === 'gcs') return 'gcloud auth login';
+  if (provider === 'azure') return 'az login';
+  if (provider === 's3') return 'aws configure sso';
+  if (provider === 'r2') return 'wrangler login';
+  return '';
+}
+
+/** 찾으면 그 경로. 못 찾으면 null. */
+export function defaultWhich(name: string, cliBin?: CliBinDeps): string | null {
+  if (!CLI_BIN_NAMES.has(name)) return null;
+  return resolveCliBin(name as CliBinName, cliBin);
+}
+
+function firstLine(text: string): string {
+  const line = text.split(/\r?\n/).map((s) => s.trim()).find((s) => s.length > 0);
+  return line ?? '';
+}
+
+function parseVersion(stdout: string, stderr: string): string | null {
+  const line = firstLine(stdout) || firstLine(stderr);
+  return line.length > 0 ? line : null;
+}
+
+function parseCount(text: string): number | null {
+  const trimmed = text.trim();
+  if (!/^\d+$/.test(trimmed)) return null;
+  const n = Number(trimmed);
+  return Number.isFinite(n) ? n : null;
+}
+
+function emptyCloud(provider: Exclude<StorageProviderId, 'local'>, platform: NodeJS.Platform): StorageProviderDetect {
+  return {
+    provider,
+    cli: { name: CLI_NAME[provider], path: null, version: null },
+    signedIn: null,
+    account: null,
+    project: null,
+    bucketCount: null,
+    hint: installHint(provider, platform),
+  };
+}
+
+async function runOk(
+  deps: StorageDetectDeps,
+  bin: string,
+  args: string[],
+): Promise<StorageCommandResult | null> {
+  try {
+    const result = await deps.run(bin, args, { timeoutMs: TIMEOUT_MS });
+    if (result.timedOut || result.code !== 0) return null;
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+// The local root comes from the same resolver object-store uses (one default · no home-relative literal — isolation gate).
+function localRoot(deps: StorageDetectDeps): string {
+  return deps.localDir ?? resolveStorageConfig(null).localDir;
+}
+
+function probeLocalWritable(dir: string): boolean {
+  try {
+    accessSync(dir, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function detectLocal(deps: StorageDetectDeps, home: string): Promise<StorageProviderDetect> {
+  const dir = localRoot(deps);
+  const writable = deps.localWritable ?? probeLocalWritable(dir);
+  return {
+    provider: 'local',
+    cli: { name: 'local', path: dir, version: null },
+    signedIn: true,
+    account: null,
+    project: null,
+    bucketCount: null,
+    hint: writable ? `${dir} 쓰기 가능` : `${dir} 쓰기 불가`,
+  };
+}
+
+async function detectGcs(deps: StorageDetectDeps, bin: string, platform: NodeJS.Platform): Promise<StorageProviderDetect> {
+  const row = emptyCloud('gcs', platform);
+  row.cli.path = bin;
+  const version = await runOk(deps, bin, ['--version']);
+  if (!version) return row;
+  row.cli.version = parseVersion(version.stdout, version.stderr);
+  const account = await runOk(deps, bin, ['config', 'get-value', 'account']);
+  const project = await runOk(deps, bin, ['config', 'get-value', 'project']);
+  if (!account && !project) {
+    row.signedIn = null;
+    row.hint = loginHint('gcs');
+    return row;
+  }
+  const accountValue = account ? firstLine(account.stdout) : '';
+  const projectValue = project ? firstLine(project.stdout) : '';
+  const unset = (value: string) => value.length === 0 || value === '(unset)';
+  if (unset(accountValue)) {
+    row.signedIn = false;
+    row.hint = loginHint('gcs');
+    row.project = unset(projectValue) ? null : projectValue;
+    return row;
+  }
+  row.signedIn = true;
+  row.account = accountValue;
+  row.project = unset(projectValue) ? null : projectValue;
+  row.hint = '';
+  const buckets = await runOk(deps, bin, ['storage', 'buckets', 'list', '--format=value(name)']);
+  if (buckets) {
+    const names = buckets.stdout.split(/\r?\n/).map((s) => s.trim()).filter((s) => s.length > 0);
+    row.bucketCount = names.length;
+  }
+  return row;
+}
+
+async function detectAzure(deps: StorageDetectDeps, bin: string, platform: NodeJS.Platform): Promise<StorageProviderDetect> {
+  const row = emptyCloud('azure', platform);
+  row.cli.path = bin;
+  const version = await runOk(deps, bin, ['version']);
+  if (!version) return row;
+  row.cli.version = parseVersion(version.stdout, version.stderr);
+  const show = await runOk(deps, bin, ['account', 'show', '--query', '{user:user.name,sub:name}', '-o', 'json']);
+  if (!show) {
+    row.signedIn = null;
+    row.hint = loginHint('azure');
+    return row;
+  }
+  let parsed: { user?: unknown; sub?: unknown } | null = null;
+  try {
+    parsed = JSON.parse(show.stdout) as { user?: unknown; sub?: unknown };
+  } catch {
+    row.signedIn = null;
+    row.hint = loginHint('azure');
+    return row;
+  }
+  const user = typeof parsed?.user === 'string' ? parsed.user.trim() : '';
+  const sub = typeof parsed?.sub === 'string' ? parsed.sub.trim() : '';
+  if (!user) {
+    row.signedIn = false;
+    row.hint = loginHint('azure');
+    return row;
+  }
+  row.signedIn = true;
+  row.account = user;
+  row.project = sub || null;
+  row.hint = '';
+  const list = await runOk(deps, bin, ['account', 'list', '--query', 'length(@)', '-o', 'tsv']);
+  if (list) row.bucketCount = parseCount(list.stdout);
+  return row;
+}
+
+async function detectS3(deps: StorageDetectDeps, bin: string, platform: NodeJS.Platform): Promise<StorageProviderDetect> {
+  const row = emptyCloud('s3', platform);
+  row.cli.path = bin;
+  const version = await runOk(deps, bin, ['--version']);
+  if (!version) return row;
+  row.cli.version = parseVersion(version.stdout, version.stderr);
+  const identity = await runOk(deps, bin, ['sts', 'get-caller-identity', '--query', 'Arn', '--output', 'text']);
+  if (!identity) {
+    row.signedIn = null;
+    row.hint = loginHint('s3');
+    return row;
+  }
+  const arn = firstLine(identity.stdout);
+  if (!arn || arn === 'None') {
+    row.signedIn = false;
+    row.hint = loginHint('s3');
+    return row;
+  }
+  row.signedIn = true;
+  row.account = arn;
+  row.hint = '';
+  const buckets = await runOk(deps, bin, ['s3api', 'list-buckets', '--query', 'length(Buckets)']);
+  if (buckets) row.bucketCount = parseCount(buckets.stdout);
+  return row;
+}
+
+async function r2FromAwsProfiles(deps: StorageDetectDeps, platform: NodeJS.Platform): Promise<StorageProviderDetect | null> {
+  const which = deps.which ?? ((name: string) => defaultWhich(name, deps.cliBin));
+  const aws = which('aws');
+  if (!aws) return null;
+  const listed = await runOk(deps, aws, ['configure', 'list-profiles']);
+  if (!listed) return null;
+  const profiles = listed.stdout.split(/\r?\n/).map((s) => s.trim()).filter((s) => s.length > 0);
+  const r2 = profiles.find((name) => name === 'r2' || name.startsWith('r2'));
+  if (!r2) return null;
+  return {
+    provider: 'r2',
+    cli: { name: 'wrangler', path: null, version: null },
+    signedIn: null,
+    account: r2,
+    project: null,
+    bucketCount: null,
+    hint: `aws profile ${r2} — ${installHint('r2', platform)}`,
+  };
+}
+
+async function detectR2(deps: StorageDetectDeps, bin: string | null, platform: NodeJS.Platform): Promise<StorageProviderDetect> {
+  if (!bin) {
+    const viaAws = await r2FromAwsProfiles(deps, platform);
+    return viaAws ?? emptyCloud('r2', platform);
+  }
+  const row = emptyCloud('r2', platform);
+  row.cli.path = bin;
+  const version = await runOk(deps, bin, ['--version']);
+  if (!version) return row;
+  row.cli.version = parseVersion(version.stdout, version.stderr);
+  const who = await runOk(deps, bin, ['whoami']);
+  if (!who) {
+    row.signedIn = null;
+    row.hint = loginHint('r2');
+    return row;
+  }
+  const text = `${who.stdout}\n${who.stderr}`;
+  const email = text.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i)?.[0] ?? null;
+  const id = text.match(/\b[0-9a-f]{32}\b/i)?.[0] ?? null;
+  if (!email && !id) {
+    row.signedIn = false;
+    row.hint = loginHint('r2');
+    return row;
+  }
+  row.signedIn = true;
+  row.account = email;
+  row.project = id;
+  row.hint = '';
+  return row;
+}
+
+export async function detectStorageProviders(deps: StorageDetectDeps): Promise<StorageProviderDetect[]> {
+  const platform = deps.platform ?? process.platform;
+  const home = deps.home ?? homedir();
+  const which = deps.which ?? ((name: string) => defaultWhich(name, deps.cliBin));
+  const rows: StorageProviderDetect[] = [];
+  rows.push(await detectLocal(deps, home));
+  const gcloud = which('gcloud');
+  rows.push(gcloud ? await detectGcs(deps, gcloud, platform) : emptyCloud('gcs', platform));
+  const az = which('az');
+  rows.push(az ? await detectAzure(deps, az, platform) : emptyCloud('azure', platform));
+  const aws = which('aws');
+  rows.push(aws ? await detectS3(deps, aws, platform) : emptyCloud('s3', platform));
+  const wrangler = which('wrangler');
+  rows.push(await detectR2(deps, wrangler, platform));
+  const found = rows.filter((row) => row.provider === 'local' || row.cli.path !== null).map((row) => row.provider);
+  const signedIn = rows.filter((row) => row.signedIn === true).map((row) => row.provider);
+  (deps.log ?? ((category, event, data) => debug.log(category, event, data)))('storage.detect', 'done', { found, signedIn });
+  return rows;
+}

package/src/surface/address.ts

@@ -46,11 +46,9 @@ export type SurfaceAddress =
   | { readonly kind: 'popover';  readonly popoverId: string }
   | { readonly kind: 'inline';   readonly inlineId: string }
   | { readonly kind: 'bg';       readonly bgId: string }
-  // B-13-α (Phase P7-B closure) — addresses a Virtual Window as a whole
-  // (layout container). Window surfaces are registered/unregistered by
-  // `window-surface-adapter` on VW spawn/close; LLM tools
-  // (SaveLayout / LoadLayout / ApplyLayoutPreset · GetUIState /
-  // DescribeSurface / ObserveSurface) accept this address.
+  // Addresses a Virtual Window as a whole (layout container).
+  // The address remains accepted by surface tools, but dashboard wiring
+  // no longer registers Virtual Windows as surfaces.
   //
   // Widget-team ack for shared-union extension: SYNC #245
   // (내부 문서 `SYNC-widget-to-term-b13-surface-address-coord`).

package/src/surface/index.ts

@@ -118,12 +118,6 @@ export {
   type WireShellRunnerSurfaceHandle,
 } from './adapters/shell-runner-wiring.js';
 
-export {
-  wireWindowSurfaces,
-  type WireWindowSurfacesOpts,
-  type WireWindowSurfacesHandle,
-} from './adapters/window-surface-adapter.js';
-
 export {
   buildGetUIStateTool,
   buildDescribeSurfaceTool,

package/src/surface/llm-tools.ts

@@ -365,8 +365,7 @@ export function dispatchDescribeSurface(
     case 'bg':
       return passthrough(addr, desc);
     case 'window': {
-      // B-13-α · Virtual Window as a surface. `desc` comes from
-      // window-surface-adapter (registered on VW spawn) — no per-kind
+      // B-13-α · Virtual Window as a surface. No per-kind
       // resolver like modal/widget because a VW is a layout container
       // rather than a single primitive. `detail` surfaces the
       // `windowId` + basic lifecycle metadata the SurfaceRegistry

package/src/surface/shell-runner-boot.ts

@@ -1,20 +1,3 @@
-import type { PaneContent } from '../virtual-windows/pane-content.js';
-import type { ExternalTerminalPaneOpts } from '../shell-runner/external-terminal-pane.js';
-import { getUserConfig } from '../user-config.js';
-import { resolveDashboardUiMode } from '../views/ui-mode.js';
-
-/** essential UI 모드 = 헤드리스: RunShell 이 VW 페인을 안 그리고 PtyCaptureEngine
- *  캡처로만 LLM 에 출력 반환(RFC §5 · P1). per-spawn 판정이라 /ui 런타임 토글도
- *  반영. --rich CLI override 는 config-level read 라 안 보이지만, 그 경우에도
- *  캡처는 동작(페인만 없음·graceful degrade). */
-function isHeadlessSurface(): boolean {
-  const uc = getUserConfig();
-  return resolveDashboardUiMode({
-    configUiMode: uc.dashboard?.uiMode,
-    legacyDefaultMode: uc.dashboard?.defaultMode,
-  }) === 'essential';
-}
-
 interface ShellRegistryLike<Handle> {}
 
 interface BackgroundSurfaceLike<Handle> {
@@ -22,12 +5,7 @@ interface BackgroundSurfaceLike<Handle> {
   forget(id: string): void;
 }
 
-interface RunnerHostsLike<Request, Host> {
-  factory(req: Request): Host | null;
-  evict(label: string): boolean;
-}
-
-export interface DashboardShellRunnerBootDeps<Request, Handle, Host> {
+export interface DashboardShellRunnerBootDeps<Handle> {
   createBackgroundSurface: (deps: {
     onUpdate: (rollup: { running: number; backgrounded: number }) => void;
   }) => BackgroundSurfaceLike<Handle>;
@@ -36,40 +14,16 @@ export interface DashboardShellRunnerBootDeps<Request, Handle, Host> {
     onUnregister: (id: string) => void;
   }) => ShellRegistryLike<Handle>;
   wireShellRunnerSurface?: (deps: { shellRegistry: ShellRegistryLike<Handle> }) => void;
-  // A pane-content factory returns a PaneContent, not `unknown` — the
-  // registry (registerPaneContentKind) requires that concrete return.
-  registerPaneContentKind: (kind: string, factory: (spec: unknown) => PaneContent) => void;
-  // Mirror the real external-terminal-pane contract exactly: `preview`
-  // is a PreviewTerminal, `focusPolicy` a FocusPolicy, and the mouse
-  // intent callback the two-arg (ev, meta) form. Reusing the owning
-  // type keeps this seam from drifting again.
-  createExternalTerminalPaneContent: (spec: ExternalTerminalPaneOpts) => PaneContent;
-  createRunnerHostFactory: (deps: {
-    getSessionCwd: () => string;
-    initialSize: () => { cols: number; rows: number };
-    onSpawnError: (label: string, err: unknown) => void;
-    onSpawn: (label: string, host: Host) => void;
-  }) => RunnerHostsLike<Request, Host>;
   createFileCaptureEngine: () => unknown;
-  // DI setter — method syntax gives bivariant parameter checking so the
-  // concrete ShellRunnerDeps (a real ShellRegistry, with fileEngine and
-  // ptyHostFactory both optional) is assignable through this structural
-  // seam. fileEngine/ptyHostFactory are optional to match that contract.
   setShellRunnerDeps(deps: {
     registry: ShellRegistryLike<Handle>;
     fileEngine?: unknown;
-    ptyHostFactory?: (req: Request) => Host | null;
   }): void;
-  getSessionCwd: () => string;
-  termSize: () => { cols: number; rows: number };
   setLatestShellRollup: (rollup: { running: number; backgrounded: number }) => void;
-  onSpawnError: (label: string, err: unknown) => void;
-  spawnVirtualWindowTerminal: (label: string, host: Host) => void;
-  subscribeVirtualWindowClose: (cb: (ev: { type: string; spawnTitle?: string | null }) => void) => void;
 }
 
-export function bootDashboardShellRunner<Request, Handle, Host>(
-  deps: DashboardShellRunnerBootDeps<Request, Handle, Host>,
+export function bootDashboardShellRunner<Handle>(
+  deps: DashboardShellRunnerBootDeps<Handle>,
 ): void {
   const bgSurface = deps.createBackgroundSurface({
     onUpdate: (rollup) => {
@@ -90,44 +44,5 @@ export function bootDashboardShellRunner<Request, Handle, Host>(
   try {
     deps.wireShellRunnerSurface?.({ shellRegistry: registry });
   } catch { /* never break boot */ }
-  try {
-    deps.registerPaneContentKind('external-terminal', (spec: any) =>
-      deps.createExternalTerminalPaneContent({
-        preview: spec.preview,
-        title: spec.title,
-        label: spec.label,
-        focusPolicy: spec.focusPolicy,
-        onTerminalMouseIntent: spec.onTerminalMouseIntent,
-      }));
-  } catch { /* already registered */ }
-  const runnerHosts = deps.createRunnerHostFactory({
-    getSessionCwd: deps.getSessionCwd,
-    initialSize: deps.termSize,
-    onSpawnError: deps.onSpawnError,
-    onSpawn: (label, host) => {
-      // P1 (RFC §5) — essential 서피스는 헤드리스: VW 페인 planting 을 아예
-      // 건너뛴다. PtyCaptureEngine 이 host 로 명령을 돌려 출력을 캡처하므로
-      // RunShell 은 페인 없이도 LLM 에 결과를 반환한다(codex unified_exec 패리티).
-      if (isHeadlessSurface()) return;
-      try {
-        deps.spawnVirtualWindowTerminal(label, host);
-      } catch {
-        // VW subsystem may not be ready yet. Keep PTY host alive and
-        // let the caller fall back to non-visible capture mode.
-      }
-    },
-  });
-  deps.setShellRunnerDeps({
-    registry,
-    fileEngine: deps.createFileCaptureEngine(),
-    ptyHostFactory: (req) => runnerHosts.factory(req),
-  });
-  try {
-    deps.subscribeVirtualWindowClose((ev) => {
-      if (ev.type !== 'window:close') return;
-      const label = ev.spawnTitle;
-      if (!label) return;
-      try { runnerHosts.evict(label); } catch { /* isolate */ }
-    });
-  } catch { /* virtual-windows not ready in early boot — skip */ }
+  deps.setShellRunnerDeps({ registry, fileEngine: deps.createFileCaptureEngine() });
 }

package/src/task-cards/card-cli.ts

@@ -0,0 +1,64 @@
+import type { Command } from 'commander';
+import { CardStore, type TaskCard } from './card-store.js';
+
+export interface CardCliDeps {
+  createStore?: () => CardStore;
+  write?: (text: string) => void;
+}
+
+function formatCard(card: TaskCard): string {
+  const lines = [
+    `ID: ${card.id}`,
+    `Goal: ${card.goalId}`,
+    `Title: ${card.title}`,
+    `Status: ${card.status}`,
+    `Created: ${card.createdAt}`,
+  ];
+  for (const section of card.sections) {
+    lines.push('', `${section.key} (${section.owner}, ${section.createdAt}):`, section.content);
+  }
+  return lines.join('\n') + '\n';
+}
+
+/** Register read-only card inspection commands without changing other task commands. */
+export function registerCardCommand(program: Command, deps: CardCliDeps = {}): Command {
+  const createStore = deps.createStore ?? (() => new CardStore());
+  const write = deps.write ?? ((text: string) => { process.stdout.write(text); });
+  const card = program.command('card').description('Inspect task cards');
+
+  card.command('show <id>')
+    .description('Show a task card and its sections')
+    .option('--json', 'Output JSON')
+    .action((id: string, options: { json?: boolean }) => {
+      const store = createStore();
+      try {
+        const result = store.getCard(id);
+        if (!result) throw new Error(`Card not found: ${id}`);
+        write(options.json ? `${JSON.stringify(result)}\n` : formatCard(result));
+      } finally {
+        store.close();
+      }
+    });
+
+  card.command('list')
+    .description('List task cards')
+    .option('--open', 'Only show open cards')
+    .option('--json', 'Output JSON')
+    .action((options: { open?: boolean; json?: boolean }) => {
+      const store = createStore();
+      try {
+        const cards = store.listCards({ open: options.open });
+        if (options.json) {
+          write(`${JSON.stringify(cards)}\n`);
+        } else {
+          write(cards.length === 0
+            ? 'No cards.\n'
+            : cards.map((item) => `${item.id}\t${item.status}\t${item.title}\t${item.goalId}\n`).join(''));
+        }
+      } finally {
+        store.close();
+      }
+    });
+
+  return card;
+}