work-ally 0.2.0-alpha.1

package/bridge/src/server-handoff-command.ts

@@ -0,0 +1,364 @@
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { loadConfig } from './config.ts';
+import { FakeRuntimeClient } from './fake-runtime-client.ts';
+import { HandoffService, type HandoffExportPayload } from './handoff-service.ts';
+import { CodexRuntimeClient } from './runtime-client.ts';
+import type { WorkSessionMeta } from './types.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+
+type CommandFailureReason = HandoffExportPayload['reason'] | 'candidate_missing' | 'candidate_ambiguous' | 'thread_handle_not_found';
+
+interface ManagedThreadCommandPayload extends Omit<HandoffExportPayload, 'reason'> {
+  status: HandoffExportPayload['status'] | 'ambiguous';
+  reason?: CommandFailureReason;
+  threadHandle: string | null;
+  candidateCount: number;
+  selector: {
+    mode: 'new' | 'default' | 'thread_handle';
+    value: string | null;
+  };
+  availableHandles?: string[];
+}
+
+interface ThreadsPayload {
+  assistant: string;
+  workspaceRoot: string;
+  assistantCodexHome: string | null;
+  defaultWorkSessionId: string | null;
+  threads: Array<{
+    workSessionId: string;
+    threadHandle: string;
+    threadName: string | null;
+    activeSurface: WorkSessionMeta['activeSurface'];
+    origin: WorkSessionMeta['origin'];
+    updatedAt: string;
+    archivedAt: string | null;
+    isDefault: boolean;
+  }>;
+}
+
+function printJson(value: unknown): void {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+function commandArgs(): string[] {
+  return process.argv.slice(4);
+}
+
+function hasFlag(flag: string): boolean {
+  return commandArgs().includes(flag);
+}
+
+function threadHandleFromArgs(args: string[]): string | null {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (value === '--thread') {
+      return String(args[index + 1] || '').trim().toLowerCase() || null;
+    }
+    if (value.startsWith('--thread=')) {
+      return value.slice('--thread='.length).trim().toLowerCase() || null;
+    }
+  }
+  return null;
+}
+
+function assistantNameFromConfig(config: ReturnType<typeof loadConfig>): string {
+  return String(config.assistant?.name || '').trim() || 'native';
+}
+
+function managedThreadCandidates(store: WorkSessionStore, assistantName: string): WorkSessionMeta[] {
+  return store
+    .listWorkSessionsForAssistant(assistantName)
+    .filter((session) => session.activeSurface !== 'closed');
+}
+
+function buildFailurePayload(
+  config: ReturnType<typeof loadConfig>,
+  reason: CommandFailureReason,
+  selector: ManagedThreadCommandPayload['selector'],
+  candidateCount: number,
+  availableHandles: string[] = [],
+): ManagedThreadCommandPayload {
+  return {
+    status: reason === 'candidate_ambiguous' ? 'ambiguous' : 'not_found',
+    reason,
+    assistantName: assistantNameFromConfig(config),
+    workspaceRoot: config.workspaceRoot,
+    assistantCodexHome: config.assistant?.codexHome || null,
+    workSessionId: null,
+    threadHandle: null,
+    runtimeThreadId: null,
+    cliResumeRef: null,
+    cliResumeRefType: 'null',
+    threadName: null,
+    activeSurface: null,
+    ownershipSource: null,
+    resumeCapability: 'not_ready',
+    command: null,
+    exportedAt: new Date().toISOString(),
+    candidateCount,
+    selector,
+    availableHandles,
+  };
+}
+
+function buildManagedPayload(
+  payload: HandoffExportPayload,
+  target: WorkSessionMeta,
+  selector: ManagedThreadCommandPayload['selector'],
+  candidateCount: number,
+): ManagedThreadCommandPayload {
+  return {
+    ...payload,
+    threadHandle: target.threadHandle,
+    candidateCount,
+    selector,
+  };
+}
+
+function printThreads(payload: ThreadsPayload): void {
+  if (!payload.threads.length) {
+    console.log('当前还没有可继续的受管线程。');
+    return;
+  }
+
+  console.log('当前受管线程：');
+  for (const thread of payload.threads) {
+    const badges = [];
+    if (thread.isDefault) {
+      badges.push('default');
+    }
+    if (thread.origin === 'codex_cli_attach') {
+      badges.push('attach');
+    }
+    if (thread.archivedAt) {
+      badges.push('archived');
+    }
+    const badgeText = badges.length ? ` [${badges.join(', ')}]` : '';
+    const preview = String(thread.threadName || '').trim() || '无标题';
+    console.log(`- ${thread.threadHandle}${badgeText} ${preview}`);
+    console.log(`  surface=${thread.activeSurface} updated=${thread.updatedAt}`);
+  }
+}
+
+function openReadyPayload(
+  payload: Pick<HandoffExportPayload, 'status' | 'command' | 'cliResumeRef' | 'workSessionId' | 'assistantCodexHome' | 'workspaceRoot'>,
+  service: HandoffService,
+): void {
+  if (payload.status !== 'ready' || !payload.command || !payload.cliResumeRef || !payload.workSessionId) {
+    printJson(payload);
+    process.exit(1);
+  }
+
+  service.markWorkSessionOfficialCli(payload.workSessionId);
+  const args = ['resume', '--cd', payload.workspaceRoot, payload.cliResumeRef];
+  const env = payload.assistantCodexHome
+    ? { ...process.env, CODEX_HOME: payload.assistantCodexHome }
+    : { ...process.env };
+  const result = spawnSync('codex', args, { stdio: 'inherit', env });
+  if (typeof result.status === 'number') {
+    process.exit(result.status);
+  }
+  if (result.error) {
+    throw result.error;
+  }
+}
+
+function createRuntimeClient(config: ReturnType<typeof loadConfig>) {
+  if (config.runtime.mode === 'fake') {
+    return new FakeRuntimeClient();
+  }
+  return new CodexRuntimeClient({ codexHome: config.assistant?.codexHome || null });
+}
+
+async function runNewCommand(
+  config: ReturnType<typeof loadConfig>,
+  store: WorkSessionStore,
+  service: HandoffService,
+): Promise<void> {
+  const runtime = createRuntimeClient(config);
+  try {
+    const thread = await runtime.startThread(config.workspaceRoot);
+    const created = store.createWorkSession({
+      assistantName: assistantNameFromConfig(config),
+      assistantCodexHome: config.assistant?.codexHome || null,
+      workspaceRoot: config.workspaceRoot,
+      runtimeThreadId: thread.id,
+      cliResumeRef: thread.id,
+      cliResumeRefType: 'session_id',
+      origin: 'work_ally',
+      activeSurface: 'official_codex_cli',
+      ownershipSource: 'explicit_codex_launch',
+    });
+    const payload = buildManagedPayload(
+      await service.exportCurrentWorkSession(created),
+      created,
+      { mode: 'new', value: created.threadHandle },
+      1,
+    );
+
+    if (hasFlag('--json')) {
+      printJson(payload);
+      if (payload.status !== 'ready') {
+        process.exit(1);
+      }
+      return;
+    }
+
+    if (hasFlag('--print')) {
+      if (payload.status !== 'ready' || !payload.command) {
+        printJson(payload);
+        process.exit(1);
+      }
+      console.log(payload.command);
+      return;
+    }
+
+    openReadyPayload(payload, service);
+  } finally {
+    await runtime.disconnect();
+  }
+}
+
+async function runContinueCommand(
+  config: ReturnType<typeof loadConfig>,
+  store: WorkSessionStore,
+  service: HandoffService,
+): Promise<void> {
+  const assistantName = assistantNameFromConfig(config);
+  const candidates = managedThreadCandidates(store, assistantName);
+  const requestedHandle = threadHandleFromArgs(commandArgs());
+  const selector = requestedHandle
+    ? { mode: 'thread_handle' as const, value: requestedHandle }
+    : { mode: 'default' as const, value: null };
+
+  let target: WorkSessionMeta | null = null;
+  if (requestedHandle) {
+    const matched = store.findWorkSessionByThreadHandle(assistantName, requestedHandle);
+    if (matched && !matched.archivedAt && matched.activeSurface !== 'closed') {
+      target = matched;
+    }
+  } else if (candidates.length === 1) {
+    target = candidates[0];
+  }
+
+  const payload = target
+    ? buildManagedPayload(await service.exportCurrentWorkSession(target), target, selector, candidates.length)
+    : buildFailurePayload(
+        config,
+        requestedHandle
+          ? 'thread_handle_not_found'
+          : candidates.length === 0
+            ? 'candidate_missing'
+            : 'candidate_ambiguous',
+        selector,
+        candidates.length,
+        candidates.map((candidate) => candidate.threadHandle),
+      );
+
+  if (hasFlag('--json')) {
+    printJson(payload);
+    if (payload.status !== 'ready') {
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (hasFlag('--print')) {
+    if (payload.status !== 'ready' || !payload.command) {
+      printJson(payload);
+      process.exit(1);
+    }
+    console.log(payload.command);
+    return;
+  }
+
+  openReadyPayload(payload, service);
+}
+
+function runThreadsCommand(config: ReturnType<typeof loadConfig>, store: WorkSessionStore): void {
+  const assistantName = assistantNameFromConfig(config);
+  const activeWorkSessionId = store.getAssistantIndex(assistantName)?.activeWorkSessionId || null;
+  const payload: ThreadsPayload = {
+    assistant: assistantName,
+    workspaceRoot: config.workspaceRoot,
+    assistantCodexHome: config.assistant?.codexHome || null,
+    defaultWorkSessionId: activeWorkSessionId,
+    threads: store.listWorkSessionsForAssistant(assistantName).map((thread) => ({
+      workSessionId: thread.workSessionId,
+      threadHandle: thread.threadHandle,
+      threadName: thread.threadName,
+      activeSurface: thread.activeSurface,
+      origin: thread.origin,
+      updatedAt: thread.updatedAt,
+      archivedAt: thread.archivedAt,
+      isDefault: thread.workSessionId === activeWorkSessionId,
+    })),
+  };
+
+  if (hasFlag('--json')) {
+    printJson(payload);
+    return;
+  }
+
+  printThreads(payload);
+}
+
+export async function runHandoffCommand(): Promise<void> {
+  const config = loadConfig();
+  const handoffKind = process.argv[3] || '';
+  const workSessionStore = new WorkSessionStore(config.paths.workSessionsDir || path.join(config.paths.runtimeDir, 'work-sessions'));
+  const service = new HandoffService(config, workSessionStore);
+
+  if (handoffKind === 'codex') {
+    const payload = await service.exportActiveWorkSessionForAssistant();
+    if (hasFlag('--print')) {
+      if (payload.status !== 'ready' || !payload.command) {
+        printJson(payload);
+        process.exit(1);
+      }
+      console.log(payload.command);
+      return;
+    }
+
+    if (hasFlag('--open')) {
+      openReadyPayload(payload, service);
+      return;
+    }
+
+    printJson(payload);
+    if (payload.status !== 'ready') {
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (handoffKind === 'attach') {
+    const payload = await service.attachFromCliArgs(commandArgs());
+    printJson(payload);
+    if (payload.status !== 'attached') {
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (handoffKind === 'threads') {
+    runThreadsCommand(config, workSessionStore);
+    return;
+  }
+
+  if (handoffKind === 'continue') {
+    await runContinueCommand(config, workSessionStore, service);
+    return;
+  }
+
+  if (handoffKind === 'new') {
+    await runNewCommand(config, workSessionStore, service);
+    return;
+  }
+
+  throw new Error(
+    'unknown handoff subcommand: ' + (handoffKind || '(missing)'),
+  );
+}

package/bridge/src/server-main.ts

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { loadConfig } from './config.ts';
+import { initializeProcessLogger, logError, logInfo, logWarn } from './logger.ts';
+import { createRuntimeApp, runRoutineCommand } from './server.ts';
+import { runHandoffCommand } from './server-handoff-command.ts';
+import { runThreadSyncCommand } from './server-thread-sync-command.ts';
+import { nowIso, writeJsonFile } from './utils.ts';
+
+export async function main(): Promise<void> {
+  if (process.argv[2] === 'routine') {
+    await runRoutineCommand();
+    return;
+  }
+
+  if (process.argv[2] === 'handoff') {
+    await runHandoffCommand();
+    return;
+  }
+
+  if (process.argv[2] === 'thread-sync') {
+    await runThreadSyncCommand();
+    return;
+  }
+
+  const config = loadConfig();
+  initializeProcessLogger({
+    logsDir: config.paths.logsDir,
+    component: 'bridge',
+    timezone: config.timezone,
+    retentionDays: config.logging.retentionDays,
+    mirrorToStdout: process.env.WORK_ALLY_FOREGROUND === '1',
+  });
+  logInfo('bridge', 'process_start', {
+    pid: process.pid,
+    workspaceRoot: config.workspaceRoot,
+    channel: config.channel.impl,
+    runtime: config.runtime.mode,
+  });
+  process.on('unhandledRejection', (reason) => {
+    logError('bridge', 'unhandled_rejection', {
+      reason: reason instanceof Error ? (reason.stack || reason.message) : String(reason),
+    });
+  });
+  process.on('uncaughtException', (error) => {
+    logError('bridge', 'uncaught_exception', {
+      error: error.stack || error.message,
+    });
+  });
+  process.on('beforeExit', (code) => {
+    logWarn('bridge', 'before_exit', { code });
+  });
+  process.on('exit', (code) => {
+    writeJsonFile(path.join(config.paths.runtimeDir, 'bridge.health.json'), {
+      status: 'stopped',
+      at: nowIso(),
+      pid: process.pid,
+      workspaceRoot: config.workspaceRoot,
+      channel: config.channel.impl,
+      runtime: config.runtime.mode,
+      exitCode: code,
+    });
+    logInfo('bridge', 'process_exit', { code });
+  });
+
+  const app = createRuntimeApp(config);
+  await app.start();
+
+  let shuttingDown = false;
+  const shutdown = async () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logInfo('bridge', 'shutdown_signal');
+    await app.stop();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/bridge/src/server-routine-command.ts

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import { loadConfig, validateConfig } from './config.ts';
+import { initializeProcessLogger, logInfo } from './logger.ts';
+import { createRuntimeApp } from './server.ts';
+import { Scheduler } from './scheduler.ts';
+
+export async function runRoutineCommand(): Promise<void> {
+  const config = loadConfig();
+  validateConfig(config);
+  const subcmd = process.argv[3] || 'list';
+  initializeProcessLogger({
+    logsDir: config.paths.logsDir,
+    component: 'routine',
+    timezone: config.timezone,
+    retentionDays: config.logging.retentionDays,
+    captureConsole: false,
+  });
+  logInfo('routine', 'command_start', {
+    pid: process.pid,
+    subcmd,
+    workspaceRoot: config.workspaceRoot,
+  });
+  const scheduler = new Scheduler(config.paths.routinesDir, path.join(config.paths.runtimeDir, 'routines-state.json'), config.timezone, config.paths.projectRoutinesDir);
+
+  if (subcmd === 'list') {
+    for (const routine of scheduler.listRoutines()) {
+      console.log(`${routine.id}\t${routine.schedule || '(manual)'}\t${routine.enabled === false ? 'disabled' : 'enabled'}`);
+    }
+    return;
+  }
+
+  const id = process.argv[4];
+  if (!id) {
+    throw new Error('routine id is required');
+  }
+
+  if (subcmd === 'enable') {
+    scheduler.enableRoutine(id);
+    console.log(`enabled ${id}`);
+    return;
+  }
+
+  if (subcmd === 'disable') {
+    scheduler.disableRoutine(id);
+    console.log(`disabled ${id}`);
+    return;
+  }
+
+  if (subcmd === 'run') {
+    const app = createRuntimeApp(config);
+    try {
+      await app.runRoutine(id);
+    } finally {
+      await app.dispose();
+    }
+    return;
+  }
+
+  throw new Error(`unknown routine subcommand: ${subcmd}`);
+}