tower-studio 0.1.3 → 0.1.6

package/src/lib/cli-test.ts

@@ -1,476 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import path from "node:path";
-import { resolveCommandPath, resolveSpawnTarget, ensurePathInEnv, stripClaudeNestingEnv } from "./platform";
-
-// ---------------------------------------------------------------------------
-// Types (from adapters/types.ts)
-// ---------------------------------------------------------------------------
-
-export interface TestResult {
-  ok: boolean;
-  checks: TestCheck[];
-}
-
-export interface TestCheck {
-  name: string;
-  passed: boolean;
-  message: string;
-}
-
-interface UsageSummary {
-  inputTokens: number;
-  outputTokens: number;
-  cachedInputTokens?: number;
-}
-
-interface RunProcessResult {
-  exitCode: number | null;
-  signal: string | null;
-  timedOut: boolean;
-  stdout: string;
-  stderr: string;
-}
-
-// ---------------------------------------------------------------------------
-// Internal process utilities (from adapters/process-utils.ts)
-// ---------------------------------------------------------------------------
-
-interface RunningProcess {
-  child: ChildProcess;
-  graceSec: number;
-}
-
-type ChildProcessWithEvents = ChildProcess & {
-  on(event: "error", listener: (err: Error) => void): ChildProcess;
-  on(
-    event: "close",
-    listener: (code: number | null, signal: NodeJS.Signals | null) => void,
-  ): ChildProcess;
-};
-
-const runningProcesses = new Map<string, RunningProcess>();
-const MAX_CAPTURE_BYTES = 4 * 1024 * 1024;
-
-function parseObject(value: unknown): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return {};
-  }
-  return value as Record<string, unknown>;
-}
-
-function asString(value: unknown, fallback: string): string {
-  return typeof value === "string" && value.length > 0 ? value : fallback;
-}
-
-function asNumber(value: unknown, fallback: number): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-
-function appendWithCap(prev: string, chunk: string, cap = MAX_CAPTURE_BYTES) {
-  const combined = prev + chunk;
-  return combined.length > cap ? combined.slice(combined.length - cap) : combined;
-}
-
-
-async function ensureCommandResolvable(
-  command: string,
-  cwd: string,
-  envVars: NodeJS.ProcessEnv,
-) {
-  const resolved = await resolveCommandPath(command, { cwd, env: envVars });
-  if (resolved) return;
-  if (command.includes("/") || command.includes("\\")) {
-    const absolute = path.isAbsolute(command) ? command : path.resolve(cwd, command);
-    throw new Error(`Command is not executable: "${command}" (resolved: "${absolute}")`);
-  }
-  throw new Error(`Command not found in PATH: "${command}"`);
-}
-
-async function runChildProcess(
-  runId: string,
-  command: string,
-  args: string[],
-  opts: {
-    cwd: string;
-    env: Record<string, string>;
-    timeoutSec: number;
-    graceSec: number;
-    onLog: (stream: "stdout" | "stderr", chunk: string) => Promise<void>;
-    onLogError?: (err: unknown, runId: string, message: string) => void;
-    stdin?: string;
-  },
-): Promise<RunProcessResult> {
-  const onLogError = opts.onLogError ?? ((err, id, msg) => console.warn({ err, runId: id }, msg));
-
-  return new Promise<RunProcessResult>((resolve, reject) => {
-    const mergedEnv = ensurePathInEnv(
-      stripClaudeNestingEnv({ ...process.env, ...opts.env }),
-    ) as NodeJS.ProcessEnv;
-
-    void resolveSpawnTarget(command, args, { cwd: opts.cwd, env: mergedEnv })
-      .then((target) => {
-        const child = spawn(target.command, target.args, {
-          cwd: opts.cwd,
-          env: mergedEnv,
-          shell: false,
-          stdio: [opts.stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
-        }) as ChildProcessWithEvents;
-
-        if (opts.stdin != null && child.stdin) {
-          child.stdin.write(opts.stdin);
-          child.stdin.end();
-        }
-
-        runningProcesses.set(runId, { child, graceSec: opts.graceSec });
-
-        let timedOut = false;
-        let stdout = "";
-        let stderr = "";
-        let logChain: Promise<void> = Promise.resolve();
-
-        const timeout =
-          opts.timeoutSec > 0
-            ? setTimeout(() => {
-                timedOut = true;
-                child.kill("SIGTERM");
-                setTimeout(() => {
-                  if (!child.killed) {
-                    child.kill("SIGKILL");
-                  }
-                }, Math.max(1, opts.graceSec) * 1000);
-              }, opts.timeoutSec * 1000)
-            : null;
-
-        child.stdout?.on("data", (chunk: unknown) => {
-          const text = String(chunk);
-          stdout = appendWithCap(stdout, text);
-          logChain = logChain
-            .then(() => opts.onLog("stdout", text))
-            .catch((err) => onLogError(err, runId, "failed to append stdout log chunk"));
-        });
-
-        child.stderr?.on("data", (chunk: unknown) => {
-          const text = String(chunk);
-          stderr = appendWithCap(stderr, text);
-          logChain = logChain
-            .then(() => opts.onLog("stderr", text))
-            .catch((err) => onLogError(err, runId, "failed to append stderr log chunk"));
-        });
-
-        child.on("error", (err: Error) => {
-          if (timeout) clearTimeout(timeout);
-          runningProcesses.delete(runId);
-          const errno = (err as NodeJS.ErrnoException).code;
-          const pathValue = mergedEnv.PATH ?? mergedEnv.Path ?? "";
-          const msg =
-            errno === "ENOENT"
-              ? `Failed to start command "${command}" in "${opts.cwd}". Verify command, working directory, and PATH (${pathValue}).`
-              : `Failed to start command "${command}" in "${opts.cwd}": ${err.message}`;
-          reject(new Error(msg));
-        });
-
-        child.on("close", (code: number | null, signal: NodeJS.Signals | null) => {
-          if (timeout) clearTimeout(timeout);
-          runningProcesses.delete(runId);
-          void logChain.finally(() => {
-            resolve({
-              exitCode: code,
-              signal,
-              timedOut,
-              stdout,
-              stderr,
-            });
-          });
-        });
-      })
-      .catch(reject);
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Parse utilities (from adapters/claude-local/parse.ts)
-// ---------------------------------------------------------------------------
-
-const CLAUDE_AUTH_REQUIRED_RE = /(?:not\s+logged\s+in|please\s+log\s+in|please\s+run\s+`?claude\s+login`?|login\s+required|requires\s+login|unauthorized|authentication\s+required)/i;
-const URL_RE = /(https?:\/\/[^\s'"`<>()[\]{};,!?]+[^\s'"`<>()[\]{};,!.?:]+)/gi;
-
-function parseJson(value: string): Record<string, unknown> | null {
-  try {
-    return JSON.parse(value) as Record<string, unknown>;
-  } catch {
-    return null;
-  }
-}
-
-function parseClaudeStreamJson(stdout: string) {
-  let sessionId: string | null = null;
-  let model = "";
-  let finalResult: Record<string, unknown> | null = null;
-  const assistantTexts: string[] = [];
-
-  for (const rawLine of stdout.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const event = parseJson(line);
-    if (!event) continue;
-
-    const type = asString(event.type, "");
-    if (type === "system" && asString(event.subtype, "") === "init") {
-      sessionId = asString(event.session_id, sessionId ?? "") || sessionId;
-      model = asString(event.model, model);
-      continue;
-    }
-
-    if (type === "assistant") {
-      sessionId = asString(event.session_id, sessionId ?? "") || sessionId;
-      const message = parseObject(event.message);
-      const content = Array.isArray(message.content) ? message.content : [];
-      for (const entry of content) {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
-        const block = entry as Record<string, unknown>;
-        if (asString(block.type, "") === "text") {
-          const text = asString(block.text, "");
-          if (text) assistantTexts.push(text);
-        }
-      }
-      continue;
-    }
-
-    if (type === "result") {
-      finalResult = event;
-      sessionId = asString(event.session_id, sessionId ?? "") || sessionId;
-    }
-  }
-
-  if (!finalResult) {
-    return {
-      sessionId,
-      model,
-      costUsd: null as number | null,
-      usage: null as UsageSummary | null,
-      summary: assistantTexts.join("\n\n").trim(),
-      resultJson: null as Record<string, unknown> | null,
-    };
-  }
-
-  const usageObj = parseObject(finalResult.usage);
-  const usage: UsageSummary = {
-    inputTokens: asNumber(usageObj.input_tokens, 0),
-    cachedInputTokens: asNumber(usageObj.cache_read_input_tokens, 0),
-    outputTokens: asNumber(usageObj.output_tokens, 0),
-  };
-  const costRaw = finalResult.total_cost_usd;
-  const costUsd = typeof costRaw === "number" && Number.isFinite(costRaw) ? costRaw : null;
-  const summary = asString(finalResult.result, assistantTexts.join("\n\n")).trim();
-
-  return {
-    sessionId,
-    model,
-    costUsd,
-    usage,
-    summary,
-    resultJson: finalResult,
-  };
-}
-
-function extractClaudeLoginUrl(text: string): string | null {
-  const match = text.match(URL_RE);
-  if (!match || match.length === 0) return null;
-  for (const rawUrl of match) {
-    const cleaned = rawUrl.replace(/[\])}.!,?;:'\"]+$/g, "");
-    if (cleaned.includes("claude") || cleaned.includes("anthropic") || cleaned.includes("auth")) {
-      return cleaned;
-    }
-  }
-  return match[0]?.replace(/[\])}.!,?;:'\"]+$/g, "") ?? null;
-}
-
-function extractClaudeErrorMessages(parsed: Record<string, unknown>): string[] {
-  const raw = Array.isArray(parsed.errors) ? parsed.errors : [];
-  const messages: string[] = [];
-
-  for (const entry of raw) {
-    if (typeof entry === "string") {
-      const msg = entry.trim();
-      if (msg) messages.push(msg);
-      continue;
-    }
-
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-      continue;
-    }
-
-    const obj = entry as Record<string, unknown>;
-    const msg = asString(obj.message, "") || asString(obj.error, "") || asString(obj.code, "");
-    if (msg) {
-      messages.push(msg);
-      continue;
-    }
-
-    try {
-      messages.push(JSON.stringify(obj));
-    } catch {
-      // skip non-serializable entry
-    }
-  }
-
-  return messages;
-}
-
-function detectClaudeLoginRequired(input: {
-  parsed: Record<string, unknown> | null;
-  stdout: string;
-  stderr: string;
-}): { requiresLogin: boolean; loginUrl: string | null } {
-  const resultText = asString(input.parsed?.result, "").trim();
-  const messages = [resultText, ...extractClaudeErrorMessages(input.parsed ?? {}), input.stdout, input.stderr]
-    .join("\n")
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-
-  const requiresLogin = messages.some((line) => CLAUDE_AUTH_REQUIRED_RE.test(line));
-  return {
-    requiresLogin,
-    loginUrl: extractClaudeLoginUrl([input.stdout, input.stderr].join("\n")),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// testEnvironment (from adapters/claude-local/test.ts)
-// ---------------------------------------------------------------------------
-
-export async function testEnvironment(cwd: string): Promise<TestResult> {
-  const checks: TestCheck[] = [];
-
-  // Check 1: verify `claude` command exists
-  try {
-    await ensureCommandResolvable("claude", cwd, { ...process.env });
-    checks.push({
-      name: "claude_command_resolvable",
-      passed: true,
-      message: "claude command found in PATH",
-    });
-  } catch (err) {
-    checks.push({
-      name: "claude_command_resolvable",
-      passed: false,
-      message: err instanceof Error ? err.message : "claude command not found in PATH",
-    });
-    return { ok: false, checks };
-  }
-
-  // Check 2: get CLI version (best-effort per D-06)
-  try {
-    const versionProbe = await runChildProcess(
-      `claude-version-${Date.now()}`,
-      "claude",
-      ["--version"],
-      {
-        cwd,
-        env: {},
-        timeoutSec: 5,
-        graceSec: 2,
-        onLog: async () => {},
-      },
-    );
-    const versionStr = (versionProbe.stdout.trim() || versionProbe.stderr.trim()) || "";
-    checks.push({
-      name: "claude_version",
-      passed: true,
-      message: versionStr ? `Version: ${versionStr}` : "Version: unknown",
-    });
-  } catch {
-    checks.push({
-      name: "claude_version",
-      passed: true,
-      message: "Version: unknown",
-    });
-  }
-
-  // Check 3: verify ANTHROPIC_API_KEY (optional — claude may use browser auth)
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  const hasApiKey = typeof apiKey === "string" && apiKey.trim().length > 0;
-  checks.push({
-    name: "anthropic_api_key",
-    passed: hasApiKey,
-    message: hasApiKey
-      ? "ANTHROPIC_API_KEY is set"
-      : "ANTHROPIC_API_KEY is not set (claude may use browser/subscription auth)",
-  });
-
-  // Check 4: run hello probe
-  const probeId = `claude-test-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  try {
-    const probe = await runChildProcess(
-      probeId,
-      "claude",
-      ["--print", "-", "--output-format", "stream-json", "--verbose"],
-      {
-        cwd,
-        env: {},
-        stdin: "Respond with just the word hello",
-        timeoutSec: 45,
-        graceSec: 5,
-        onLog: async () => {},
-      },
-    );
-
-    const parsedStream = parseClaudeStreamJson(probe.stdout);
-    const parsed = parsedStream.resultJson;
-    const loginMeta = detectClaudeLoginRequired({
-      parsed,
-      stdout: probe.stdout,
-      stderr: probe.stderr,
-    });
-
-    if (loginMeta.requiresLogin) {
-      const hint = loginMeta.loginUrl
-        ? `Run \`claude login\` and complete sign-in at ${loginMeta.loginUrl}`
-        : "Run `claude login` to authenticate";
-      checks.push({
-        name: "claude_hello_probe",
-        passed: false,
-        message: `Claude login required. ${hint}`,
-      });
-    } else if (probe.timedOut) {
-      checks.push({
-        name: "claude_hello_probe",
-        passed: false,
-        message: "Claude hello probe timed out",
-      });
-    } else if ((probe.exitCode ?? 1) === 0) {
-      const summary = parsedStream.summary.trim();
-      const hasHello = /\bhello\b/i.test(summary);
-      checks.push({
-        name: "claude_hello_probe",
-        passed: hasHello,
-        message: hasHello
-          ? "Claude hello probe succeeded"
-          : `Claude probe ran but returned unexpected output: ${summary.slice(0, 120)}`,
-      });
-    } else {
-      const stderrLine =
-        probe.stderr
-          .split(/\r?\n/)
-          .map((l) => l.trim())
-          .find(Boolean) ?? "";
-      checks.push({
-        name: "claude_hello_probe",
-        passed: false,
-        message: stderrLine
-          ? `Claude hello probe failed: ${stderrLine}`
-          : `Claude hello probe failed with exit code ${probe.exitCode ?? -1}`,
-      });
-    }
-  } catch (err) {
-    checks.push({
-      name: "claude_hello_probe",
-      passed: false,
-      message: err instanceof Error ? err.message : "Claude hello probe threw an error",
-    });
-  }
-
-  const ok = checks.every((c) => c.passed || c.name === "anthropic_api_key");
-  return { ok, checks };
-}

package/src/lib/config-defaults.ts

@@ -1,121 +0,0 @@
-export interface ConfigEntry {
-  defaultValue: unknown;
-  type: "string" | "number" | "boolean" | "object";
-  label: string;
-}
-
-export const CONFIG_DEFAULTS: Record<string, ConfigEntry> = {
-  "git.pathMappingRules": {
-    defaultValue: [],
-    type: "object",
-    label: "Git Path Mapping Rules",
-  },
-  "system.maxUploadBytes": {
-    defaultValue: 52428800,
-    type: "number",
-    label: "Max Upload Size (bytes)",
-  },
-  "system.maxConcurrentExecutions": {
-    defaultValue: 20,
-    type: "number",
-    label: "Max Concurrent Executions",
-  },
-  "git.timeoutSec": {
-    defaultValue: 30,
-    type: "number",
-    label: "Git Operation Timeout (seconds)",
-  },
-  "search.resultLimit": {
-    defaultValue: 20,
-    type: "number",
-    label: "Search Result Limit",
-  },
-  "search.allModeCap": {
-    defaultValue: 5,
-    type: "number",
-    label: "All-Mode Per-Type Cap",
-  },
-  "search.debounceMs": {
-    defaultValue: 250,
-    type: "number",
-    label: "Search Debounce (ms)",
-  },
-  "search.snippetLength": {
-    defaultValue: 80,
-    type: "number",
-    label: "Snippet Length (characters)",
-  },
-  "missions.grid.minCols": {
-    defaultValue: 1,
-    type: "number",
-    label: "Grid Min Columns",
-  },
-  "missions.grid.maxCols": {
-    defaultValue: 5,
-    type: "number",
-    label: "Grid Max Columns",
-  },
-  "missions.grid.minRows": {
-    defaultValue: 1,
-    type: "number",
-    label: "Grid Min Rows",
-  },
-  "missions.grid.maxRows": {
-    defaultValue: 5,
-    type: "number",
-    label: "Grid Max Rows",
-  },
-  "terminal.app": {
-    defaultValue: "Terminal",
-    type: "string",
-    label: "Default Terminal App",
-  },
-  "terminal.wsPort": {
-    defaultValue: 3001,
-    type: "number",
-    label: "WebSocket Port",
-  },
-  "terminal.idleTimeoutSec": {
-    defaultValue: 180,
-    type: "number",
-    label: "Idle Timeout (seconds)",
-  },
-  "assistant.systemPrompt": {
-    defaultValue: [
-      "You are Tower Assistant — the built-in AI operator for the Tower task management platform.",
-      "",
-      "## Identity",
-      "- You are a task management operator, NOT a coding assistant.",
-      "- You can ONLY use Tower MCP tools. You CANNOT read files, edit code, run shell commands, or search the web.",
-      "- Always respond in the same language the user uses.",
-      "",
-      "## Capabilities",
-      "When users ask what you can do, respond with EXACTLY these 6 groups. Translate to the user's language.",
-      "",
-      "1. **Workspace & Project** — View, create, update, delete workspaces and projects. Search projects and repositories.",
-      "2. **Task Management** — Create tasks (priority, labels, worktree branch isolation, sub-path, auto-start). Move task status (TODO → IN_PROGRESS → IN_REVIEW → DONE / CANCELLED). Update task info and labels.",
-      "3. **Execution Monitor** — Start task execution, check execution status, get terminal output, send commands to running terminals.",
-      "4. **Daily Report & Todo** — Generate daily work summary (completed + in-progress). View pending task list sorted by priority.",
-      "5. **Labels & Notes & Assets** — Manage workspace labels, project notes, and file attachments.",
-      "6. **Global Search** — Search tasks, projects, repositories, notes, and assets by keyword.",
-      "",
-      "Do NOT list any capabilities beyond the above. Do NOT mention code editing, debugging, testing, git operations, or any development capabilities.",
-      "",
-      "## Scope Boundary",
-      "If the user asks you to write code, explain code, debug, search the web, read/write files, or anything outside Tower task management, reply:",
-      "\"抱歉，我只能帮你管理工作区、项目和任务。编码、调试等操作请在任务终端中完成。\"",
-    ].join("\n"),
-    type: "string",
-    label: "Assistant System Prompt",
-  },
-  "assistant.displayMode": {
-    defaultValue: "sidebar",
-    type: "string",
-    label: "Assistant Display Mode",
-  },
-  "assistant.communicationMode": {
-    defaultValue: "chat",
-    type: "string",
-    label: "Assistant Communication Mode",
-  },
-};

package/src/lib/config-reader.ts

@@ -1,16 +0,0 @@
-/**
- * Thin config reader for non-Next.js server modules (process-manager, adapters).
- * Does NOT use "use server" or next/cache — safe to import from any Node.js context.
- * Mirrors the getConfigValue logic from config-actions.ts without Next.js dependencies.
- */
-import { db } from "@/lib/db";
-
-export async function readConfigValue<T>(key: string, defaultValue: T): Promise<T> {
-  const row = await db.systemConfig.findUnique({ where: { key } });
-  if (!row) return defaultValue;
-  try {
-    return JSON.parse(row.value) as T;
-  } catch {
-    return defaultValue;
-  }
-}

package/src/lib/constants.ts

@@ -1,26 +0,0 @@
-import type { TaskStatus } from "@prisma/client";
-
-export const BOARD_COLUMNS: { id: TaskStatus; label: string; color: string }[] = [
-  { id: "TODO", label: "To Do", color: "bg-slate-400" },
-  { id: "IN_PROGRESS", label: "In Progress", color: "bg-amber-400" },
-  { id: "IN_REVIEW", label: "In Review", color: "bg-sky-400" },
-  { id: "DONE", label: "Done", color: "bg-emerald-400" },
-  { id: "CANCELLED", label: "Cancelled", color: "bg-rose-400" },
-];
-
-export const PRIORITY_CONFIG = {
-  LOW: { label: "低", color: "bg-slate-500/20 text-slate-300 border border-slate-500/30" },
-  MEDIUM: { label: "中", color: "bg-amber-500/20 text-amber-300 border border-amber-500/30" },
-  HIGH: { label: "高", color: "bg-orange-500/20 text-orange-300 border border-orange-500/30" },
-  CRITICAL: { label: "紧急", color: "bg-rose-500/20 text-rose-300 border border-rose-500/30" },
-} as const;
-
-/** System label name for project workbench tasks — hidden from kanban board */
-export const TOWER_LABEL_NAME = "Tower";
-export const TOWER_LABEL_COLOR = "#8b5cf6"; // purple
-
-export const AGENTS = ["CLAUDE_CODE", "MINIMAX"] as const;
-export type AgentType = (typeof AGENTS)[number];
-
-export const NOTE_CATEGORIES_PRESET = ["账号", "环境", "需求", "备忘"] as const;
-export type NoteCategoryPreset = (typeof NOTE_CATEGORIES_PRESET)[number];

package/src/lib/db.ts

@@ -1,28 +0,0 @@
-import { PrismaClient } from "@prisma/client";
-
-const globalForPrisma = globalThis as unknown as {
-  prisma: PrismaClient | undefined;
-};
-
-export const db =
-  globalForPrisma.prisma ??
-  new PrismaClient({
-    log: process.env.NODE_ENV === "development" ? ["query"] : [],
-  });
-
-if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;
-
-let initialized = false;
-
-export async function initDb(): Promise<PrismaClient> {
-  if (initialized) return db;
-  await db.$connect();
-  await db.$queryRaw`PRAGMA journal_mode=WAL`;
-  await db.$queryRaw`PRAGMA busy_timeout=5000`;
-  initialized = true;
-  return db;
-}
-
-// Ensure WAL is flushed and connections closed on exit
-process.on("SIGTERM", () => { db.$disconnect().catch(() => {}); });
-process.on("SIGINT", () => { db.$disconnect().catch(() => {}); });