tower-studio 0.1.1 → 0.1.3

package/src/lib/ai/__tests__/capability-resolver.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    aiCapabilityConfig: {
+      findUnique: vi.fn(),
+    },
+  },
+}));
+
+import { resolveCliAdapter, resolveQueryAdapter } from "../capability-resolver";
+import { db } from "@/lib/db";
+import { AiProviderError } from "../types";
+
+describe("capability-resolver", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("resolveCliAdapter", () => {
+    it("returns Claude adapter when no config exists (default)", async () => {
+      vi.mocked(db.aiCapabilityConfig.findUnique).mockResolvedValue(null);
+      const result = await resolveCliAdapter("terminal");
+      expect(result.provider.name).toBe("claude");
+      expect(result.adapter).toBeDefined();
+    });
+
+    it("returns configured provider adapter with model", async () => {
+      vi.mocked(db.aiCapabilityConfig.findUnique).mockResolvedValue({
+        id: "1", slot: "terminal", provider: "claude", mode: "cli", model: "opus",
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+      const result = await resolveCliAdapter("terminal");
+      expect(result.provider.name).toBe("claude");
+      expect(result.model).toBe("opus");
+    });
+
+    it("throws AiProviderError for unknown provider", async () => {
+      vi.mocked(db.aiCapabilityConfig.findUnique).mockResolvedValue({
+        id: "1", slot: "terminal", provider: "nonexistent", mode: "cli", model: null,
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+      await expect(resolveCliAdapter("terminal")).rejects.toThrow(AiProviderError);
+    });
+
+    it("throws for provider without CLI support", async () => {
+      // This tests the UNSUPPORTED_MODE path — would need a provider registered without cli
+      vi.mocked(db.aiCapabilityConfig.findUnique).mockResolvedValue({
+        id: "1", slot: "terminal", provider: "nonexistent", mode: "cli", model: null,
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+      try {
+        await resolveCliAdapter("terminal");
+      } catch (e) {
+        expect(e).toBeInstanceOf(AiProviderError);
+        expect((e as AiProviderError).code).toBe("CLI_NOT_FOUND");
+      }
+    });
+  });
+
+  describe("resolveQueryAdapter", () => {
+    it("throws UNSUPPORTED_MODE when provider has no query adapter for mode", async () => {
+      vi.mocked(db.aiCapabilityConfig.findUnique).mockResolvedValue({
+        id: "1", slot: "summary", provider: "claude", mode: "api", model: null,
+        createdAt: new Date(), updatedAt: new Date(),
+      });
+      // Claude doesn't have api adapter registered yet
+      await expect(resolveQueryAdapter("summary")).rejects.toThrow(AiProviderError);
+    });
+  });
+});

package/src/lib/ai/__tests__/claude-cli-adapter.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ClaudeCliAdapter } from "../adapters/cli/claude-cli-adapter";
+import type { CliSpawnOptions } from "../types";
+
+describe("ClaudeCliAdapter", () => {
+  let adapter: ClaudeCliAdapter;
+
+  beforeEach(() => {
+    adapter = new ClaudeCliAdapter();
+  });
+
+  describe("buildSpawnArgs", () => {
+    const baseOpts: CliSpawnOptions = {
+      taskId: "ctask123456789012345678",
+      prompt: "Fix the bug",
+      cwd: "/project",
+    };
+
+    it("builds fresh start args with prompt as last argument", () => {
+      const result = adapter.buildSpawnArgs(baseOpts);
+      expect(result.command).toBe("claude");
+      expect(result.args[result.args.length - 1]).toBe("Fix the bug");
+      expect(result.initialInput).toBeUndefined();
+    });
+
+    it("builds resume args with --resume flag", () => {
+      const result = adapter.buildSpawnArgs({
+        ...baseOpts,
+        resumeSessionId: "session-abc-123",
+      });
+      expect(result.args).toContain("--resume");
+      expect(result.args).toContain("session-abc-123");
+      expect(result.args[result.args.length - 1]).not.toBe("Fix the bug");
+    });
+
+    it("builds continue args with --continue flag and no prompt", () => {
+      const result = adapter.buildSpawnArgs({
+        ...baseOpts,
+        continueLatest: true,
+      });
+      expect(result.args).toContain("--continue");
+      expect(result.args).not.toContain("Fix the bug");
+    });
+
+    it("merges profileArgs into args", () => {
+      const result = adapter.buildSpawnArgs({
+        ...baseOpts,
+        profileArgs: ["--model", "opus"],
+      });
+      expect(result.args).toContain("--model");
+      expect(result.args).toContain("opus");
+    });
+
+    it("merges profileEnvVars into env", () => {
+      const result = adapter.buildSpawnArgs({
+        ...baseOpts,
+        profileEnvVars: { CUSTOM_VAR: "value" },
+      });
+      expect(result.env.CUSTOM_VAR).toBe("value");
+    });
+  });
+
+  describe("buildEnvOverrides", () => {
+    it("returns TOWER_* env vars", () => {
+      const env = adapter.buildEnvOverrides({
+        taskId: "ctask123",
+        taskTitle: "Test task",
+        apiUrl: "http://localhost:3000",
+      });
+      expect(env.TOWER_TASK_ID).toBe("ctask123");
+      expect(env.TOWER_TASK_TITLE).toBe("Test task");
+      expect(env.TOWER_API_URL).toBe("http://localhost:3000");
+      expect(env.TOWER_STARTED_AT).toBeDefined();
+    });
+
+    it("includes CALLBACK_URL when provided", () => {
+      const env = adapter.buildEnvOverrides({
+        taskId: "ctask123",
+        taskTitle: "Test",
+        apiUrl: "http://localhost:3000",
+        callbackUrl: "http://external/callback",
+      });
+      expect(env.CALLBACK_URL).toBe("http://external/callback");
+    });
+
+    it("omits CALLBACK_URL when not provided", () => {
+      const env = adapter.buildEnvOverrides({
+        taskId: "ctask123",
+        taskTitle: "Test",
+        apiUrl: "http://localhost:3000",
+      });
+      expect(env.CALLBACK_URL).toBeUndefined();
+    });
+  });
+
+  describe("metadata", () => {
+    it("returns correct config paths", () => {
+      expect(adapter.getConfigDir()).toContain(".claude");
+      expect(adapter.getSettingsPath()).toContain("settings.json");
+      expect(adapter.getSessionsDir()).toContain("projects");
+    });
+  });
+});

package/src/lib/ai/__tests__/provider-registry.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { ProviderRegistry } from "../provider-registry";
+import type { ProviderDefinition } from "../types";
+import { ClaudeCliAdapter } from "../adapters/cli/claude-cli-adapter";
+
+function makeClaudeProvider(): ProviderDefinition {
+  return {
+    name: "claude",
+    displayName: "Claude Code",
+    agentFieldValue: "CLAUDE_CODE",
+    cli: {
+      command: "claude",
+      adapter: new ClaudeCliAdapter(),
+    },
+    models: {
+      cli: ["sonnet", "opus", "haiku"],
+      api: [],
+    },
+  };
+}
+
+describe("ProviderRegistry", () => {
+  let registry: ProviderRegistry;
+
+  beforeEach(() => {
+    registry = new ProviderRegistry();
+  });
+
+  it("registers and retrieves a provider", () => {
+    registry.register(makeClaudeProvider());
+    const provider = registry.get("claude");
+    expect(provider).toBeDefined();
+    expect(provider!.displayName).toBe("Claude Code");
+  });
+
+  it("returns undefined for unknown provider", () => {
+    expect(registry.get("unknown")).toBeUndefined();
+  });
+
+  it("returns CLI adapter for registered provider", () => {
+    registry.register(makeClaudeProvider());
+    const adapter = registry.getCliAdapter("claude");
+    expect(adapter).toBeDefined();
+  });
+
+  it("returns null CLI adapter for provider without CLI", () => {
+    registry.register({
+      ...makeClaudeProvider(),
+      name: "api-only",
+      cli: undefined,
+    });
+    expect(registry.getCliAdapter("api-only")).toBeNull();
+  });
+
+  it("returns all allowed commands from registered CLI providers", () => {
+    registry.register(makeClaudeProvider());
+    expect(registry.getAllowedCommands()).toContain("claude");
+  });
+
+  it("lists all providers", () => {
+    registry.register(makeClaudeProvider());
+    expect(registry.getAll()).toHaveLength(1);
+  });
+
+  it("returns null query adapter for unregistered provider", () => {
+    expect(registry.getQueryAdapter("nonexistent", "api")).toBeNull();
+  });
+
+  it("returns null query adapter when mode not supported", () => {
+    registry.register(makeClaudeProvider());
+    // Claude provider has no api adapter registered yet
+    expect(registry.getQueryAdapter("claude", "api")).toBeNull();
+  });
+});

package/src/lib/ai/adapters/cli/claude-cli-adapter.ts

@@ -0,0 +1,166 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveCommandPathSync } from "@/lib/platform";
+import type { CliAdapter, CliSpawnOptions, CliSpawnResult } from "../../types";
+
+const CLAUDE_MODELS = ["sonnet", "opus", "haiku", "claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5-20251001"];
+
+export class ClaudeCliAdapter implements CliAdapter {
+
+  buildSpawnArgs(opts: CliSpawnOptions): CliSpawnResult {
+    const args: string[] = [];
+
+    if (opts.profileArgs?.length) {
+      args.push(...opts.profileArgs);
+    }
+
+    if (opts.resumeSessionId) {
+      args.push("--resume", opts.resumeSessionId);
+    } else if (opts.continueLatest) {
+      args.push("--continue");
+    } else {
+      if (opts.prompt) {
+        args.push(opts.prompt);
+      }
+    }
+
+    const env: Record<string, string> = {
+      ...(opts.profileEnvVars ?? {}),
+      ...(opts.envOverrides ?? {}),
+    };
+
+    return {
+      command: this.resolveCommand(),
+      args,
+      env,
+    };
+  }
+
+  buildEnvOverrides(opts: {
+    taskId: string;
+    taskTitle: string;
+    apiUrl: string;
+    callbackUrl?: string;
+  }): Record<string, string> {
+    const env: Record<string, string> = {
+      TOWER_TASK_ID: opts.taskId,
+      TOWER_TASK_TITLE: opts.taskTitle,
+      TOWER_STARTED_AT: new Date().toISOString(),
+      TOWER_API_URL: opts.apiUrl,
+    };
+    if (opts.callbackUrl) {
+      env.CALLBACK_URL = opts.callbackUrl;
+    }
+    return env;
+  }
+
+  async installHooks(_apiUrl: string): Promise<void> {
+    const settings = this.readSettings();
+    const hooks = (settings["hooks"] as Record<string, unknown>) ?? {};
+    const entries = this.getPostToolUseArray(settings);
+
+    if (this.findTowerHookIndex(entries) >= 0) return;
+
+    const hookPath = path.join(process.cwd(), "scripts", "post-tool-hook.js");
+    const newEntry = {
+      hooks: [{ command: `node "${hookPath}"`, timeout: 10, type: "command" }],
+      matcher: "Write|Edit|MultiEdit",
+    };
+
+    settings["hooks"] = { ...hooks, PostToolUse: [...entries, newEntry] };
+    this.writeSettings(settings);
+  }
+
+  async uninstallHooks(): Promise<void> {
+    const settings = this.readSettings();
+    const hooks = (settings["hooks"] as Record<string, unknown>) ?? {};
+    const entries = this.getPostToolUseArray(settings);
+    const filtered = entries.filter(
+      (e) => !e.hooks?.some((h: { command?: string }) => h.command?.includes("post-tool-hook.js"))
+    );
+    settings["hooks"] = { ...hooks, PostToolUse: filtered };
+    this.writeSettings(settings);
+  }
+
+  async isHooksInstalled(): Promise<boolean> {
+    const settings = this.readSettings();
+    const entries = this.getPostToolUseArray(settings);
+    return this.findTowerHookIndex(entries) >= 0;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    const version = await this.getVersion();
+    return version !== null;
+  }
+
+  async getVersion(): Promise<string | null> {
+    try {
+      const { execFile } = await import("child_process");
+      const { promisify } = await import("util");
+      const execFileAsync = promisify(execFile);
+      const cmd = this.resolveCommand();
+      const { stdout } = await execFileAsync(cmd, ["--version"], { timeout: 5000 });
+      return stdout.trim() || null;
+    } catch {
+      return null;
+    }
+  }
+
+  async getModels(): Promise<string[]> {
+    return CLAUDE_MODELS;
+  }
+
+  getConfigDir(): string {
+    return path.join(os.homedir(), ".claude");
+  }
+
+  getSettingsPath(): string {
+    return path.join(this.getConfigDir(), "settings.json");
+  }
+
+  getSessionsDir(): string {
+    return path.join(this.getConfigDir(), "projects");
+  }
+
+  /** Resolve claude binary — env var > platform-aware resolution.
+   *  Public so claude-session.ts can reuse instead of duplicating findClaudeBinary(). */
+  resolveCommand(): string {
+    if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
+    if (process.platform === "win32") {
+      const native = resolveCommandPathSync("claude-code");
+      if (native !== "claude-code") return native;
+    }
+    return resolveCommandPathSync("claude");
+  }
+
+  private readSettings(): Record<string, unknown> {
+    try {
+      return JSON.parse(fs.readFileSync(this.getSettingsPath(), "utf-8")) as Record<string, unknown>;
+    } catch {
+      return {};
+    }
+  }
+
+  private writeSettings(data: Record<string, unknown>): void {
+    const dir = this.getConfigDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(this.getSettingsPath(), JSON.stringify(data, null, 2), "utf-8");
+  }
+
+  private getPostToolUseArray(settings: Record<string, unknown>): Array<{
+    hooks: Array<{ command: string; timeout: number; type: string }>;
+    matcher: string;
+  }> {
+    const hooks = settings["hooks"] as Record<string, unknown> | undefined;
+    if (!hooks) return [];
+    const arr = hooks["PostToolUse"];
+    return Array.isArray(arr) ? arr : [];
+  }
+
+  private findTowerHookIndex(entries: Array<{ hooks: Array<{ command?: string }> }>): number {
+    return entries.findIndex((e) =>
+      e.hooks?.some((h) => h.command?.includes("post-tool-hook.js"))
+    );
+  }
+}

package/src/lib/ai/capability-resolver.ts

@@ -0,0 +1,81 @@
+import { db } from "@/lib/db";
+import { providerRegistry } from "./providers";
+import { AiProviderError } from "./types";
+import type { CliAdapter, AiQueryAdapter, ProviderDefinition, AiSlot } from "./types";
+
+const DEFAULT_PROVIDER = "claude";
+const DEFAULT_MODE = "cli";
+
+interface ResolvedCliAdapter {
+  adapter: CliAdapter;
+  provider: ProviderDefinition;
+  model?: string;
+}
+
+interface ResolvedQueryAdapter {
+  adapter: AiQueryAdapter;
+  provider: ProviderDefinition;
+  model?: string;
+}
+
+async function loadSlotConfig(slot: AiSlot) {
+  return db.aiCapabilityConfig.findUnique({ where: { slot } });
+}
+
+export async function resolveCliAdapter(slot: "terminal"): Promise<ResolvedCliAdapter> {
+  const config = await loadSlotConfig(slot);
+  const providerName = config?.provider ?? DEFAULT_PROVIDER;
+  const model = config?.model ?? undefined;
+
+  const providerDef = providerRegistry.get(providerName);
+  if (!providerDef) {
+    throw new AiProviderError("CLI_NOT_FOUND", providerName, `Provider "${providerName}" 未注册`);
+  }
+
+  const adapter = providerDef.cli?.adapter;
+  if (!adapter) {
+    throw new AiProviderError(
+      "UNSUPPORTED_MODE",
+      providerName,
+      `Provider "${providerName}" 不支持 CLI 模式`
+    );
+  }
+
+  return { adapter, provider: providerDef, model };
+}
+
+export async function resolveQueryAdapter(
+  slot: "summary" | "dreaming" | "analysis" | "assistant"
+): Promise<ResolvedQueryAdapter> {
+  const config = await loadSlotConfig(slot);
+  const providerName = config?.provider ?? DEFAULT_PROVIDER;
+  const mode = config?.mode ?? DEFAULT_MODE;
+  const model = config?.model ?? undefined;
+
+  const providerDef = providerRegistry.get(providerName);
+  if (!providerDef) {
+    throw new AiProviderError("CLI_NOT_FOUND", providerName, `Provider "${providerName}" 未注册`);
+  }
+
+  const adapter = providerRegistry.getQueryAdapter(providerName, mode as "api" | "cli");
+  if (!adapter) {
+    throw new AiProviderError(
+      "UNSUPPORTED_MODE",
+      providerName,
+      `Provider "${providerName}" 不支持 ${mode} 查询模式`
+    );
+  }
+
+  if (model) {
+    const availableModels = providerDef.models[mode as "cli" | "api"] ?? [];
+    if (availableModels.length > 0 && !availableModels.includes(model)) {
+      throw new AiProviderError(
+        "MODEL_NOT_AVAILABLE",
+        providerName,
+        `模型 "${model}" 在 ${providerName} ${mode} 模式下不可用`
+      );
+    }
+  }
+
+  return { adapter, provider: providerDef, model };
+}

package/src/lib/ai/provider-registry.ts

@@ -0,0 +1,54 @@
+import type { CliAdapter, AiQueryAdapter, ProviderDefinition, ProviderAvailability } from "./types";
+
+export class ProviderRegistry {
+  private providers = new Map<string, ProviderDefinition>();
+
+  register(provider: ProviderDefinition): void {
+    this.providers.set(provider.name, provider);
+  }
+
+  get(name: string): ProviderDefinition | undefined {
+    return this.providers.get(name);
+  }
+
+  getAll(): ProviderDefinition[] {
+    return Array.from(this.providers.values());
+  }
+
+  getCliAdapter(name: string): CliAdapter | null {
+    return this.providers.get(name)?.cli?.adapter ?? null;
+  }
+
+  getQueryAdapter(name: string, mode: "api" | "cli"): AiQueryAdapter | null {
+    const provider = this.providers.get(name);
+    if (!provider) return null;
+    if (mode === "api") return provider.api?.adapter ?? null;
+    return provider.cliQuery?.adapter ?? null;
+  }
+
+  getAllowedCommands(): string[] {
+    const commands: string[] = [];
+    for (const p of this.providers.values()) {
+      if (p.cli?.command) commands.push(p.cli.command);
+    }
+    return commands;
+  }
+
+  async getAvailableProviders(): Promise<ProviderAvailability[]> {
+    const results: ProviderAvailability[] = [];
+    for (const p of this.providers.values()) {
+      const cliAvailable = p.cli ? await p.cli.adapter.isAvailable() : false;
+      const cliVersion = cliAvailable && p.cli ? await p.cli.adapter.getVersion() : null;
+      const apiKeyConfigured = p.api ? !!process.env[p.api.keyEnvVar] : false;
+      const apiAvailable = p.api ? apiKeyConfigured : false;
+
+      results.push({
+        name: p.name,
+        displayName: p.displayName,
+        cli: { available: cliAvailable, version: cliVersion },
+        api: { available: apiAvailable, keyConfigured: apiKeyConfigured },
+      });
+    }
+    return results;
+  }
+}

package/src/lib/ai/providers/claude.ts

@@ -0,0 +1,19 @@
+import type { ProviderDefinition } from "../types";
+import { ClaudeCliAdapter } from "../adapters/cli/claude-cli-adapter";
+
+export function createClaudeProvider(): ProviderDefinition {
+  return {
+    name: "claude",
+    displayName: "Claude Code",
+    agentFieldValue: "CLAUDE_CODE",
+    cli: {
+      command: "claude",
+      adapter: new ClaudeCliAdapter(),
+    },
+    // api and cliQuery adapters will be added in Phase 2
+    models: {
+      cli: ["sonnet", "opus", "haiku", "claude-sonnet-4-6", "claude-opus-4-6", "claude-haiku-4-5-20251001"],
+      api: [],
+    },
+  };
+}

package/src/lib/ai/providers/index.ts

@@ -0,0 +1,12 @@
+import { ProviderRegistry } from "../provider-registry";
+import { createClaudeProvider } from "./claude";
+
+// Singleton registry — survives HMR via globalThis
+const g = globalThis as typeof globalThis & { __providerRegistry?: ProviderRegistry };
+if (!g.__providerRegistry) {
+  const registry = new ProviderRegistry();
+  registry.register(createClaudeProvider());
+  g.__providerRegistry = registry;
+}
+
+export const providerRegistry = g.__providerRegistry;