work-ally 0.2.0-alpha.1

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

@@ -0,0 +1,222 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { ChannelAdapter } from './channel-types.ts';
+import {
+  clearBridgeDeliveryIssue,
+  describeChannelDeliveryIssue,
+  isNonFatalChannelDeliveryError,
+  normalizeChannelDeliveryError,
+  recordBridgeDeliveryIssue,
+} from './channel-delivery.ts';
+import type { loadConfig } from './config.ts';
+import { FakeRuntimeClient } from './fake-runtime-client.ts';
+import { logWarn } from './logger.ts';
+import { buildMemoryDigestPrompt, parseMemoryDigestReply } from './memory-digest.ts';
+import { CodexRuntimeClient } from './runtime-client.ts';
+import { Scheduler, type RoutineDefinition } from './scheduler.ts';
+import { SessionStore } from './session-store.ts';
+import { formatSystemNoticeText, resolveNoticeConversationRef } from './system-notify.ts';
+import { nowIso, todayStamp } from './utils.ts';
+
+type RuntimeLike = FakeRuntimeClient | CodexRuntimeClient;
+
+type BridgeConfig = ReturnType<typeof loadConfig>;
+
+const ROUTINE_DEVELOPER_INSTRUCTIONS = [
+  'You are running as a non-interactive work-ally routine.',
+  'Do not ask the user for approval during this routine.',
+  'Do not modify workspace files directly from the runtime.',
+  'Read files as needed, then return the result in your final response only.',
+  'work-ally will handle writeback, push delivery, and memory file persistence outside the runtime.',
+].join(' ');
+
+export function startRoutineThread(runtime: RuntimeLike, cwd: string) {
+  if (runtime instanceof CodexRuntimeClient) {
+    return runtime.startThread(cwd, {
+      developerInstructions: ROUTINE_DEVELOPER_INSTRUCTIONS,
+    });
+  }
+  return runtime.startThread(cwd);
+}
+
+export function resumeRoutineThread(runtime: RuntimeLike, threadId: string, cwd: string) {
+  if (runtime instanceof CodexRuntimeClient) {
+    return runtime.resumeThread(threadId, cwd, {
+      developerInstructions: ROUTINE_DEVELOPER_INSTRUCTIONS,
+    });
+  }
+  return runtime.resumeThread(threadId, cwd);
+}
+
+function formatMemoryDigestSummary(summary: string | null | undefined): string {
+  const trimmed = String(summary || '').trim();
+  if (!trimmed) {
+    return '记忆整理已完成：无新增稳定记忆。';
+  }
+  return `记忆整理已完成。\n${trimmed}`;
+}
+
+function routineTurnSandboxPolicy(cwd: string) {
+  return {
+    type: 'readOnly' as const,
+    networkAccess: false,
+    access: {
+      type: 'restricted' as const,
+      includePlatformDefaults: true,
+      readableRoots: [cwd],
+    },
+  };
+}
+
+function normalizeDeliveryError(channelImpl: string, error: unknown): Error {
+  if (channelImpl === 'feishu') {
+    return normalizeChannelDeliveryError('feishu', error);
+  }
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+
+export async function executeRoutine(
+  config: BridgeConfig,
+  channel: ChannelAdapter,
+  runtime: RuntimeLike,
+  routine: RoutineDefinition,
+  threadId: string,
+  slot?: string,
+) {
+  const conversationRef = {
+    channel: config.channel.impl,
+    conversationId: config.defaultPushTarget || 'routine-runner',
+    userId: config.defaultPushTarget || 'routine-runner',
+    chatType: 'system',
+  };
+  const dateStamp = todayStamp(slot ? new Date(slot) : new Date(), config.timezone);
+  const prompt = routine.type === 'memory_digest'
+    ? buildMemoryDigestPrompt(config, dateStamp, routine.id)
+    : routine.prompt || `run routine: ${routine.id}`;
+  const startedAt = nowIso();
+
+
+  const result = await runtime.runTurn({
+    threadId,
+    prompt,
+    messageId: `routine:${routine.id}`,
+    cwd: config.workspaceRoot,
+    ...(runtime instanceof CodexRuntimeClient ? {
+      approvalPolicy: 'never',
+      sandboxPolicy: routineTurnSandboxPolicy(config.workspaceRoot),
+    } : {}),
+    onProgress: async (text) => {
+    },
+  });
+
+
+  let memoryDigestSummary: string | null = null;
+  if (routine.type === 'memory_digest' && result.status === 'completed') {
+    const parsed = parseMemoryDigestReply(result.reply);
+    const dailyPath = path.join(config.paths.dailyMemoryDir, `${dateStamp}.md`);
+    const longTermPath = path.join(config.paths.longTermMemoryDir, 'MEMORY.md');
+    if (parsed) {
+      fs.writeFileSync(dailyPath, `${parsed.daily}\n`, 'utf8');
+      fs.writeFileSync(longTermPath, `${parsed.longTerm}\n`, 'utf8');
+      memoryDigestSummary = formatMemoryDigestSummary(parsed.summary);
+    } else {
+      fs.writeFileSync(dailyPath, `${result.reply}\n`, 'utf8');
+      fs.writeFileSync(longTermPath, `${result.reply}\n`, 'utf8');
+      memoryDigestSummary = '记忆整理已完成，但未生成结构化摘要。';
+    }
+  }
+
+  const shouldNotifyMemoryDigest = routine.type === 'memory_digest' && Boolean(memoryDigestSummary);
+  if (shouldNotifyMemoryDigest) {
+    let noticeRef = config.defaultPushTarget ? conversationRef : null;
+    if (!noticeRef && config.channel.impl === 'feishu') {
+      const sessionStore = new SessionStore(config.paths.sessionsDir);
+      noticeRef = resolveNoticeConversationRef(sessionStore.listSessions(), config)?.conversationRef || null;
+    }
+    if (noticeRef) {
+      const outbound = {
+        type: 'progress_update' as const,
+        conversationRef: noticeRef,
+        text: formatSystemNoticeText(memoryDigestSummary || ''),
+      };
+      try {
+        await channel.send(outbound);
+        clearBridgeDeliveryIssue(config.paths.runtimeDir);
+      } catch (error) {
+        const normalizedError = normalizeDeliveryError(config.channel.impl, error);
+        if (isNonFatalChannelDeliveryError(normalizedError)) {
+          recordBridgeDeliveryIssue(config.paths.runtimeDir, normalizedError);
+          logWarn('routine', 'memory_digest_notice_delivery_unavailable', {
+            routineId: routine.id,
+            slot: slot || null,
+            threadId,
+            ...describeChannelDeliveryIssue(normalizedError),
+          });
+        } else {
+          throw normalizedError;
+        }
+      }
+    }
+  } else if (routine.push?.kind === 'default_im' && config.defaultPushTarget) {
+    const outbound = {
+      type: result.status === 'completed' ? 'final_reply' as const : 'error_reply' as const,
+      conversationRef,
+      text: result.status === 'completed' ? result.reply : (result.error || `routine failed: ${routine.id}`),
+    };
+    try {
+      await channel.send(outbound);
+      clearBridgeDeliveryIssue(config.paths.runtimeDir);
+    } catch (error) {
+      const normalizedError = normalizeDeliveryError(config.channel.impl, error);
+      if (isNonFatalChannelDeliveryError(normalizedError)) {
+        recordBridgeDeliveryIssue(config.paths.runtimeDir, normalizedError);
+        logWarn('routine', 'push_delivery_unavailable', {
+          routineId: routine.id,
+          slot: slot || null,
+          threadId,
+          ...describeChannelDeliveryIssue(normalizedError),
+        });
+      } else {
+        throw normalizedError;
+      }
+    }
+  }
+
+  if (routine.writeback?.kind === 'append_markdown' && routine.writeback.path && result.status === 'completed') {
+    const target = path.join(config.workspaceRoot, routine.writeback.path);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.appendFileSync(target, `\n\n${result.reply}\n`, 'utf8');
+  }
+
+  return result;
+}
+
+export async function resolveRoutineThread(
+  runtime: RuntimeLike,
+  scheduler: Scheduler,
+  config: BridgeConfig,
+  routine: RoutineDefinition,
+): Promise<{ id: string }> {
+  if (routine.thread_mode === 'reuse') {
+    const existingThreadId = scheduler.getRoutineThread(routine.id);
+    if (existingThreadId) {
+      try {
+        const resumed = await resumeRoutineThread(runtime, existingThreadId, config.workspaceRoot);
+        scheduler.bindRoutineThread(routine.id, resumed.id);
+        return resumed;
+      } catch {
+        scheduler.clearRoutineThread(routine.id);
+      }
+    }
+
+    const created = await startRoutineThread(runtime, config.workspaceRoot);
+    scheduler.bindRoutineThread(routine.id, created.id);
+    return created;
+  }
+
+  scheduler.clearRoutineThread(routine.id);
+  return startRoutineThread(runtime, config.workspaceRoot);
+}

package/bridge/src/server-runtime-app-support.ts

@@ -0,0 +1,107 @@
+import type { ChannelAdapter } from './channel-types.ts';
+import {
+  clearBridgeDeliveryIssue,
+  describeChannelDeliveryIssue,
+  isNonFatalChannelDeliveryError,
+  normalizeChannelDeliveryError,
+  recordBridgeDeliveryIssue,
+} from './channel-delivery.ts';
+import type { loadConfig } from './config.ts';
+import { logInfo, logWarn } from './logger.ts';
+import { Receiver } from './receiver.ts';
+import { SessionStore } from './session-store.ts';
+import { resolveNoticeConversationRef } from './system-notify.ts';
+import type { ConversationRef } from './types.ts';
+import { nowIso, readJsonFile, writeJsonFile } from './utils.ts';
+
+type BridgeConfig = ReturnType<typeof loadConfig>;
+
+export function normalizeDeliveryError(channelImpl: string, error: unknown): Error {
+  if (channelImpl === 'feishu') {
+    return normalizeChannelDeliveryError('feishu', error);
+  }
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+
+export async function reconcilePendingFinalRepliesOnStartup(
+  sessionStore: SessionStore,
+  receiver: Receiver,
+): Promise<void> {
+  const sessions = sessionStore.listSessions();
+  for (const session of sessions) {
+    const delivered = await receiver.redeliverPendingFinalReplies(session.conversationRef as ConversationRef);
+    if (delivered > 0) {
+      logInfo('bridge', 'startup_pending_final_replies_redelivered', {
+        conversationId: session.conversationRef.conversationId,
+        delivered,
+      });
+    }
+  }
+}
+
+export async function notifyRuntimeState(
+  config: BridgeConfig,
+  channel: ChannelAdapter,
+  text: string,
+): Promise<void> {
+  if (config.channel.impl !== 'feishu') {
+    return;
+  }
+  const sessionStore = new SessionStore(config.paths.sessionsDir);
+  const target = resolveNoticeConversationRef(sessionStore.listSessions(), config);
+  if (!target) {
+    return;
+  }
+  const outbound = {
+    type: 'progress_update' as const,
+    conversationRef: target.conversationRef,
+    text,
+  };
+  try {
+    await channel.send(outbound);
+    clearBridgeDeliveryIssue(config.paths.runtimeDir);
+  } catch (error) {
+    const normalizedError = normalizeDeliveryError(config.channel.impl, error);
+    if (isNonFatalChannelDeliveryError(normalizedError)) {
+      recordBridgeDeliveryIssue(config.paths.runtimeDir, normalizedError);
+      logWarn('bridge', 'runtime_state_delivery_unavailable', {
+        ...describeChannelDeliveryIssue(normalizedError),
+      });
+      return;
+    }
+    throw normalizedError;
+  }
+}
+
+export function writeBridgeHealth(options: {
+  healthFile: string;
+  config: BridgeConfig;
+  stopping: boolean;
+  status: string;
+  error?: string;
+}): void {
+  const { healthFile, config, stopping, status, error } = options;
+  if (stopping && status === 'running') {
+    return;
+  }
+  const current = readJsonFile(healthFile, null);
+  const deliveryState = current && typeof current === 'object'
+    ? Object.fromEntries(
+        Object.entries(current).filter(([key]) => key.startsWith('delivery_')),
+      )
+    : {};
+  const health = {
+    ...deliveryState,
+    status,
+    at: nowIso(),
+    pid: process.pid,
+    workspaceRoot: config.workspaceRoot,
+    channel: config.channel.impl,
+    runtime: config.runtime.mode,
+    ...(error ? { error } : {}),
+  };
+  writeJsonFile(healthFile, health);
+}

package/bridge/src/server-runtime-app.ts

@@ -0,0 +1,238 @@
+import path from 'node:path';
+import type { ChannelAdapter, InboundHandler } from './channel-types.ts';
+import { FakeChannelAdapter } from './channels/fake/adapter.ts';
+import { FeishuAdapter } from './channels/feishu/adapter.ts';
+import {
+  describeChannelDeliveryIssue,
+  isNonFatalChannelDeliveryError,
+  recordBridgeDeliveryIssue,
+} from './channel-delivery.ts';
+import { loadConfig } from './config.ts';
+import { FakeRuntimeClient } from './fake-runtime-client.ts';
+import { logError, logInfo, logWarn } from './logger.ts';
+import { Receiver } from './receiver.ts';
+import { CodexRuntimeClient } from './runtime-client.ts';
+import { Scheduler, type RoutineDefinition } from './scheduler.ts';
+import {
+  normalizeDeliveryError,
+  notifyRuntimeState,
+  reconcilePendingFinalRepliesOnStartup,
+  writeBridgeHealth,
+} from './server-runtime-app-support.ts';
+import { executeRoutine, resolveRoutineThread } from './server-routine-execution.ts';
+import { SessionStore } from './session-store.ts';
+import { nowIso, writeJsonFile } from './utils.ts';
+
+type RuntimeLike = FakeRuntimeClient | CodexRuntimeClient;
+
+class InboundProxy implements InboundHandler {
+  private target: InboundHandler | null = null;
+
+  bind(target: InboundHandler): void {
+    this.target = target;
+  }
+
+  async handleInbound(message: Parameters<InboundHandler['handleInbound']>[0]): Promise<void> {
+    if (!this.target) {
+      throw new Error('inbound handler is not ready');
+    }
+    await this.target.handleInbound(message);
+  }
+}
+
+export class RuntimeApp {
+  private readonly config;
+  private readonly channel;
+  private readonly runtime;
+  private readonly scheduler;
+  private readonly sessionStore;
+  private readonly receiver;
+  private readonly healthFile;
+  private readonly timers: NodeJS.Timeout[] = [];
+  private stopping = false;
+
+  constructor(
+    config: ReturnType<typeof loadConfig>,
+    channel: ChannelAdapter,
+    runtime: RuntimeLike,
+    scheduler: Scheduler,
+    sessionStore: SessionStore,
+    receiver: Receiver,
+  ) {
+    this.config = config;
+    this.channel = channel;
+    this.runtime = runtime;
+    this.scheduler = scheduler;
+    this.sessionStore = sessionStore;
+    this.receiver = receiver;
+    this.healthFile = path.join(config.paths.runtimeDir, 'bridge.health.json');
+  }
+
+  async start(): Promise<void> {
+    logInfo('bridge', 'channel_starting', {
+      impl: this.config.channel.impl,
+      runtime: this.config.runtime.mode,
+    });
+    await this.channel.start();
+    logInfo('bridge', 'channel_started', {
+      impl: this.config.channel.impl,
+    });
+    const healthy = await this.runtime.healthcheck();
+    if (!healthy) {
+      logError('bridge', 'runtime_healthcheck_failed', {
+        transport: 'stdio',
+      });
+      await notifyRuntimeState(this.config, this.channel, '**【系统消息】** Codex runtime 当前不可用，bridge 未能完成启动。');
+      throw new Error('runtime healthcheck failed');
+    }
+    logInfo('bridge', 'runtime_healthy', {
+      transport: 'stdio',
+    });
+    await reconcilePendingFinalRepliesOnStartup(this.sessionStore, this.receiver);
+    writeBridgeHealth({ healthFile: this.healthFile, config: this.config, stopping: this.stopping, status: 'running' });
+    this.timers.push(setInterval(() => {
+      if (this.stopping) {
+        return;
+      }
+      writeBridgeHealth({ healthFile: this.healthFile, config: this.config, stopping: this.stopping, status: 'running' });
+    }, 5000));
+    this.timers.push(setInterval(() => {
+      if (this.stopping) {
+        return;
+      }
+      this.tickScheduler().catch((error) => {
+        const normalizedError = normalizeDeliveryError(this.config.channel.impl, error);
+        if (isNonFatalChannelDeliveryError(normalizedError)) {
+          recordBridgeDeliveryIssue(this.config.paths.runtimeDir, normalizedError);
+          logWarn('bridge', 'scheduler_tick_delivery_unavailable', {
+            ...describeChannelDeliveryIssue(normalizedError),
+          });
+          writeBridgeHealth({ healthFile: this.healthFile, config: this.config, stopping: this.stopping, status: 'running' });
+          return;
+        }
+        logError('bridge', 'scheduler_tick_failed', {
+          error: normalizedError instanceof Error ? (normalizedError.stack || normalizedError.message) : String(normalizedError),
+        });
+        writeBridgeHealth({
+          healthFile: this.healthFile,
+          config: this.config,
+          stopping: this.stopping,
+          status: 'degraded',
+          error: String(normalizedError),
+        });
+      });
+    }, 30000));
+  }
+
+  async stop(): Promise<void> {
+    if (this.stopping) {
+      return;
+    }
+    this.stopping = true;
+    logInfo('bridge', 'app_stopping');
+    for (const timer of this.timers) {
+      clearInterval(timer);
+    }
+    await this.dispose();
+    writeBridgeHealth({ healthFile: this.healthFile, config: this.config, stopping: this.stopping, status: 'stopped' });
+    logInfo('bridge', 'app_stopped');
+  }
+
+  async dispose(): Promise<void> {
+    await this.channel.stop();
+    if (typeof this.runtime.disconnect === 'function') {
+      await this.runtime.disconnect();
+    }
+  }
+
+  async runRoutine(id: string, slot?: string): Promise<void> {
+    const routine = this.scheduler.listRoutines().find((item) => item.id === id);
+    if (!routine) {
+      throw new Error(`routine not found: ${id}`);
+    }
+
+    if (!this.scheduler.claimRun(routine.id)) {
+      logWarn('routine', 'busy_skip', { routineId: routine.id });
+      console.log(`routine busy, skipping: ${routine.id}`);
+      return;
+    }
+
+    logInfo('routine', 'run_start', {
+      routineId: routine.id,
+      slot: slot || null,
+    });
+    try {
+      const thread = await this.resolveRoutineThread(routine);
+      const effectiveSlot = slot || this.scheduler.previousSlotForRoutine(routine) || undefined;
+      const result = await executeRoutine(this.config, this.channel, this.runtime, routine, thread.id, effectiveSlot);
+      const at = nowIso();
+      const runFile = path.join(this.config.paths.runsDir, `${at.replace(/[:.]/g, '-')}-${routine.id}.json`);
+      writeJsonFile(runFile, { routine, result, slot: effectiveSlot || null, threadId: thread.id, at });
+      writeJsonFile(path.join(this.config.paths.runsDir, 'latest.json'), { routine: routine.id, result, slot: effectiveSlot || null, threadId: thread.id, at });
+      this.scheduler.markRun(routine.id, effectiveSlot || at);
+      logInfo('routine', 'run_completed', {
+        routineId: routine.id,
+        slot: effectiveSlot || null,
+        status: result.status,
+      });
+    } catch (error) {
+      this.scheduler.releaseRun(routine.id);
+      const normalizedError = normalizeDeliveryError(this.config.channel.impl, error);
+      logError('routine', 'run_failed', {
+        routineId: routine.id,
+        slot: slot || null,
+        error: normalizedError instanceof Error ? (normalizedError.stack || normalizedError.message) : String(normalizedError),
+      });
+      throw normalizedError;
+    }
+  }
+
+  private async resolveRoutineThread(routine: RoutineDefinition): Promise<{ id: string }> {
+    return resolveRoutineThread(this.runtime, this.scheduler, this.config, routine);
+  }
+
+  private async tickScheduler(): Promise<void> {
+    for (const due of this.scheduler.computeDue()) {
+      await this.runRoutine(due.routine.id, due.slot);
+    }
+  }
+}
+
+function createRuntime(config: ReturnType<typeof loadConfig>): RuntimeLike {
+  return config.runtime.mode === 'fake'
+    ? new FakeRuntimeClient()
+    : new CodexRuntimeClient({
+        codexHome: config.assistant.codexHome || null,
+      });
+}
+
+function createChannel(config: ReturnType<typeof loadConfig>, inbound: InboundHandler): ChannelAdapter {
+  if (config.channel.impl === 'fake') {
+    return new FakeChannelAdapter(inbound);
+  }
+
+  if (config.channel.impl === 'feishu') {
+    if (!config.feishu.appId || !config.feishu.appSecret) {
+      throw new Error('feishu credentials are required');
+    }
+    return new FeishuAdapter(inbound, {
+      appId: config.feishu.appId,
+      appSecret: config.feishu.appSecret,
+      reactEmoji: config.feishu.reactEmoji,
+      allowedUserIds: config.channel.allowedUserIds,
+    });
+  }
+
+  throw new Error(`unsupported channel impl: ${config.channel.impl}`);
+}
+
+export function createRuntimeApp(config: ReturnType<typeof loadConfig>): RuntimeApp {
+  const runtime = createRuntime(config);
+  const scheduler = new Scheduler(config.paths.routinesDir, path.join(config.paths.runtimeDir, 'routines-state.json'), config.timezone, config.paths.projectRoutinesDir);
+  const sessionStore = new SessionStore(config.paths.sessionsDir);
+  const inboundProxy = new InboundProxy();
+  const channel = createChannel(config, inboundProxy);
+  const receiver = new Receiver(config, channel, sessionStore, runtime);
+  inboundProxy.bind(receiver);
+  return new RuntimeApp(config, channel, runtime, scheduler, sessionStore, receiver);
+}

package/bridge/src/server-thread-sync-command.ts

@@ -0,0 +1,63 @@
+import { loadConfig } from './config.ts';
+import { FakeRuntimeClient } from './fake-runtime-client.ts';
+import { CodexRuntimeClient } from './runtime-client.ts';
+import { syncAllActiveWorkSessions, syncThreadConversationById } from './thread-sync.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+
+function commandArgs(): string[] {
+  return process.argv.slice(3);
+}
+
+function pickThreadId(args: string[]): string | null {
+  for (let i = 0; i < args.length; i += 1) {
+    const value = String(args[i] || '').trim();
+    if (value === '--thread') {
+      return String(args[i + 1] || '').trim() || null;
+    }
+    if (value.startsWith('--thread=')) {
+      return value.slice('--thread='.length).trim() || null;
+    }
+  }
+  return null;
+}
+
+function hasFlag(flag: string): boolean {
+  return commandArgs().includes(flag);
+}
+
+function createRuntime(config: ReturnType<typeof loadConfig>) {
+  if (config.runtime.mode === 'fake') {
+    return new FakeRuntimeClient();
+  }
+  return new CodexRuntimeClient({ codexHome: config.assistant?.codexHome || null });
+}
+
+export async function runThreadSyncCommand(): Promise<void> {
+  const config = loadConfig();
+  const runtime = createRuntime(config);
+  const store = new WorkSessionStore(config.paths.workSessionsDir || `${config.paths.runtimeDir}/work-sessions`);
+
+  try {
+    await runtime.connect?.();
+
+    const threadId = pickThreadId(commandArgs());
+    if (threadId) {
+      const result = await syncThreadConversationById(config, runtime, threadId);
+      if (hasFlag('--json')) {
+        console.log(JSON.stringify({ status: 'ok', mode: 'single', result }, null, 2));
+        return;
+      }
+      console.log(`thread sync completed: ${threadId}`);
+      return;
+    }
+
+    const result = await syncAllActiveWorkSessions(config, runtime, store);
+    if (hasFlag('--json')) {
+      console.log(JSON.stringify({ status: 'ok', mode: 'active_sessions', result }, null, 2));
+      return;
+    }
+    console.log(`thread sync completed: synced=${result.synced} skipped=${result.skipped} failed=${result.failed}`);
+  } finally {
+    await runtime.disconnect();
+  }
+}

package/bridge/src/server.ts

@@ -0,0 +1,17 @@
+import { pathToFileURL } from 'node:url';
+import { main as runServerMain } from './server-main.ts';
+
+export { executeRoutine } from './server-routine-execution.ts';
+export { runHandoffCommand } from './server-handoff-command.ts';
+export { main } from './server-main.ts';
+export { runRoutineCommand } from './server-routine-command.ts';
+export { RuntimeApp, createRuntimeApp } from './server-runtime-app.ts';
+
+const isCliEntrypoint = Boolean(process.argv[1]) && import.meta.url === pathToFileURL(process.argv[1]).href;
+
+if (isCliEntrypoint) {
+  runServerMain().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}