kartman-dev 1.0.0-dev.0

package/dist/index.js

@@ -0,0 +1,653 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/start.ts
+import { Command } from "commander";
+
+// src/linear/agent.ts
+import { LinearClient } from "@linear/sdk";
+
+// src/agent.ts
+import * as fs from "fs";
+import * as path from "path";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/config.ts
+import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, renameSync } from "fs";
+import { dirname, resolve, join } from "path";
+import { fileURLToPath } from "url";
+var PLUGIN_DIRNAME = "agent-plugin";
+function getBundledConfigPath() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  return resolve(__dirname, "claude-config");
+}
+function getPluginPath(cwd = process.cwd()) {
+  return join(cwd, PLUGIN_DIRNAME);
+}
+function installClaudeConfig(cwd = process.cwd()) {
+  const bundledPath = getBundledConfigPath();
+  if (!existsSync(bundledPath)) {
+    console.warn("Warning: Bundled claude-config not found. Skipping plugin installation.");
+    return;
+  }
+  const pluginDir = getPluginPath(cwd);
+  mkdirSync(pluginDir, { recursive: true });
+  cpSync(bundledPath, pluginDir, { recursive: true, force: true });
+  const underscorePlugin = join(pluginDir, "_claude-plugin");
+  const dotPlugin = join(pluginDir, ".claude-plugin");
+  if (existsSync(underscorePlugin)) {
+    renameSync(underscorePlugin, dotPlugin);
+  }
+  const underscoreMcp = join(pluginDir, "_mcp.json");
+  const dotMcp = join(pluginDir, ".mcp.json");
+  if (existsSync(underscoreMcp)) {
+    renameSync(underscoreMcp, dotMcp);
+  }
+  const gitignorePath = join(cwd, ".gitignore");
+  if (existsSync(gitignorePath)) {
+    const content = readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(PLUGIN_DIRNAME)) {
+      appendFileSync(gitignorePath, `
+# Kartman agent plugin (installed at runtime)
+${PLUGIN_DIRNAME}/
+`);
+    }
+  }
+  console.log(`Installed agent plugin to ${pluginDir}`);
+}
+
+// src/agent.ts
+var Agent = class {
+  currentSessionId;
+  isRunning = false;
+  externalSessionId;
+  activeQuery;
+  pendingToolUses = /* @__PURE__ */ new Map();
+  constructor(externalSessionId) {
+    this.externalSessionId = externalSessionId;
+  }
+  // ============================================
+  // Interrupt mechanism (private)
+  // ============================================
+  get interruptPath() {
+    return path.join("/tmp", `agent-${this.externalSessionId}.interrupt`);
+  }
+  get isInterrupted() {
+    try {
+      if (fs.existsSync(this.interruptPath)) {
+        return fs.readFileSync(this.interruptPath, "utf-8").trim() === "true";
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  requestInterrupt() {
+    fs.writeFileSync(this.interruptPath, "true", "utf-8");
+  }
+  clearInterrupt() {
+    try {
+      if (fs.existsSync(this.interruptPath)) {
+        fs.unlinkSync(this.interruptPath);
+      }
+    } catch {
+    }
+  }
+  // ============================================
+  // Event methods - Override in subclasses
+  // ============================================
+  /**
+   * Called when agent starts processing
+   */
+  async onStart() {
+  }
+  /**
+   * Called when agent emits a thinking/reasoning text
+   */
+  async onThinking(block, isSubagent) {
+  }
+  /**
+   * Called when agent starts using a tool (before result is available)
+   */
+  async onToolUse(block, isSubagent) {
+  }
+  /**
+   * Called when a tool completes with its result
+   */
+  async onToolResult(block, result, isSubagent) {
+  }
+  /**
+   * Called when agent updates its plan (via TodoWrite)
+   */
+  async onPlanUpdate(todos, isSubagent) {
+  }
+  /**
+   * Called when agent completes successfully
+   */
+  async onComplete(message) {
+  }
+  /**
+   * Called when agent encounters an error
+   */
+  async onError(error) {
+  }
+  /**
+   * Called when agent is stopped via stop command
+   */
+  async onStop() {
+  }
+  // ============================================
+  // Main execution logic
+  // ============================================
+  /**
+   * Run the agent with the given prompt
+   */
+  async run(runOptions) {
+    const {
+      prompt,
+      sessionId,
+      resumeSession = false,
+      forkSession = false,
+      cwd = process.cwd(),
+      options: additionalOptions = {}
+    } = runOptions;
+    this.isRunning = true;
+    let resultSessionId = sessionId ?? "";
+    let finalResult;
+    let wasInterrupted = false;
+    this.clearInterrupt();
+    try {
+      await this.onStart();
+      process.env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
+      const sdkOptions = {
+        settingSources: ["project"],
+        permissionMode: "bypassPermissions",
+        allowDangerouslySkipPermissions: true,
+        plugins: [{ type: "local", path: getPluginPath(cwd) }],
+        systemPrompt: {
+          preset: "claude_code",
+          type: "preset"
+        },
+        cwd,
+        ...additionalOptions
+      };
+      if (resumeSession && sessionId) {
+        sdkOptions.resume = sessionId;
+        sdkOptions.forkSession = forkSession;
+      }
+      console.log(`[Agent.run] resume=${resumeSession} | sdkResume=${sdkOptions.resume ?? "none"} | pluginPath=${getPluginPath(cwd)}`);
+      console.log(`[Agent.run] prompt=${prompt.substring(0, 300)}...`);
+      this.activeQuery = query({ prompt, options: sdkOptions });
+      for await (const message of this.activeQuery) {
+        if (this.isInterrupted) {
+          console.log("Interrupt flag detected, stopping agent...");
+          await this.activeQuery.interrupt();
+          wasInterrupted = true;
+          break;
+        }
+        if (message.type === "system") {
+          const sysMsg = message;
+          if (sysMsg.subtype === "init") {
+            resultSessionId = sysMsg.session_id;
+            this.currentSessionId = sysMsg.session_id;
+            console.log(`[Agent.run] SDK session initialized: ${sysMsg.session_id}`);
+          }
+        }
+        if (message.type === "assistant") {
+          await this.processAssistantMessage(message);
+        }
+        if (message.type === "user") {
+          await this.processUserMessage(message);
+        }
+        if (message.type === "result") {
+          const resultMsg = message;
+          if (resultMsg.subtype === "success" && resultMsg.result) {
+            finalResult = resultMsg.result;
+          }
+          await this.onComplete(resultMsg);
+        }
+      }
+      return {
+        sessionId: resultSessionId,
+        result: finalResult,
+        interrupted: wasInterrupted
+      };
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      await this.onError(err);
+      return {
+        sessionId: resultSessionId,
+        error: err.message,
+        interrupted: wasInterrupted
+      };
+    } finally {
+      this.isRunning = false;
+      this.activeQuery = void 0;
+      this.clearInterrupt();
+    }
+  }
+  /**
+   * Stop the agent session
+   * Sets interrupt flag and calls onStop callback
+   */
+  async stop() {
+    this.requestInterrupt();
+    await this.onStop();
+  }
+  /**
+   * Process an assistant message: emit thinking, buffer tool uses for later matching
+   */
+  async processAssistantMessage(message) {
+    const content = message.message.content;
+    const isSubagent = message.parent_tool_use_id !== null;
+    for (const block of content) {
+      if (block.type === "text") {
+        await this.onThinking(block, isSubagent);
+      }
+      if (block.type === "tool_use") {
+        if (block.name === "TodoWrite") {
+          const input = block.input;
+          if (input.todos) {
+            await this.onPlanUpdate(input.todos, isSubagent);
+          }
+        } else {
+          await this.onToolUse(block, isSubagent);
+          this.pendingToolUses.set(block.id, { block, isSubagent });
+        }
+      }
+    }
+  }
+  /**
+   * Process a user message: match tool results to buffered tool uses
+   */
+  async processUserMessage(message) {
+    const content = message.message.content;
+    if (typeof content === "string") return;
+    for (const block of content) {
+      if (block.type !== "tool_result") continue;
+      const resultBlock = block;
+      const pending = this.pendingToolUses.get(resultBlock.tool_use_id);
+      if (!pending) continue;
+      this.pendingToolUses.delete(resultBlock.tool_use_id);
+      let result = "";
+      if (typeof resultBlock.content === "string") {
+        result = resultBlock.content;
+      } else if (Array.isArray(resultBlock.content)) {
+        result = resultBlock.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      }
+      await this.onToolResult(pending.block, result, pending.isSubagent);
+    }
+  }
+};
+
+// src/linear/agent.ts
+var LinearAgent = class _LinearAgent extends Agent {
+  linearClient;
+  linearSessionId;
+  lastThoughtTime = 0;
+  thoughtDebounceMs = 1e3;
+  isCompleted = false;
+  constructor(config) {
+    super(config.linearSessionId);
+    this.linearClient = new LinearClient({ accessToken: config.linearAccessToken });
+    this.linearSessionId = config.linearSessionId;
+  }
+  async onStart() {
+    await this.sendActivity("thought" /* Thought */, "Starting work...", true);
+  }
+  async onThinking(block, isSubagent) {
+    if (this.isCompleted) return;
+    const now = Date.now();
+    if (now - this.lastThoughtTime < this.thoughtDebounceMs) return;
+    this.lastThoughtTime = now;
+    const content = block.text;
+    if (content.length < 20) return;
+    await this.sendActivity("thought" /* Thought */, content, false);
+  }
+  /** Tools that should show immediately on use (not wait for result) */
+  static SHOW_ON_USE = /* @__PURE__ */ new Set(["Task", "Read", "Grep", "Glob", "WebSearch", "WebFetch"]);
+  async onToolUse(block, isSubagent) {
+    if (this.isCompleted) return;
+    if (!_LinearAgent.SHOW_ON_USE.has(block.name)) return;
+    if (block.name === "Task") {
+      const subagentType = String(block.input.subagent_type ?? "subagent");
+      await this.sendActionActivity("Delegating", subagentType, void 0, false);
+      return;
+    }
+    const { action, parameter } = this.formatToolAction(block);
+    await this.sendActionActivity(action, parameter, void 0, isSubagent);
+  }
+  async onToolResult(block, result, isSubagent) {
+    if (this.isCompleted) return;
+    if (_LinearAgent.SHOW_ON_USE.has(block.name)) return;
+    const { action, parameter } = this.formatToolAction(block);
+    const truncatedResult = result.length > 1e3 ? result.substring(0, 1e3) + "..." : result;
+    await this.sendActionActivity(action, parameter, truncatedResult || void 0, isSubagent);
+  }
+  async onPlanUpdate(steps, isSubagent) {
+    if (steps.length === 0) return;
+    const linearSteps = steps.map((step) => ({
+      content: step.content,
+      status: this.mapStatusToLinear(step.status)
+    }));
+    try {
+      await this.linearClient.updateAgentSession(this.linearSessionId, {
+        plan: linearSteps
+      });
+    } catch (error) {
+      console.error("Failed to update Linear plan:", error);
+    }
+  }
+  async onComplete(message) {
+    this.isCompleted = true;
+    const text = message.subtype === "success" && message.result ? message.result : "Task completed successfully.";
+    await this.sendActivity("response" /* Response */, text, false);
+  }
+  async onError(error) {
+    this.isCompleted = true;
+    await this.sendActivity("error" /* Error */, `Error: ${error.message}`, false);
+  }
+  async onStop() {
+    this.isCompleted = true;
+    await this.sendActivity("response" /* Response */, "Session stopped", false);
+  }
+  // ============================================
+  // Helper methods
+  // ============================================
+  async sendActivity(type, body, ephemeral) {
+    try {
+      await this.linearClient.createAgentActivity({
+        agentSessionId: this.linearSessionId,
+        content: { type, body },
+        ephemeral
+      });
+    } catch (error) {
+      console.error("Failed to send Linear activity:", error);
+    }
+  }
+  async sendActionActivity(action, parameter, result, ephemeral) {
+    try {
+      const content = {
+        type: "action" /* Action */,
+        action,
+        parameter
+      };
+      if (result) content.result = result;
+      await this.linearClient.createAgentActivity({
+        agentSessionId: this.linearSessionId,
+        content,
+        ephemeral
+      });
+    } catch (error) {
+      console.error("Failed to send Linear activity:", error);
+    }
+  }
+  formatToolAction(block) {
+    const { name, input } = block;
+    const params = input;
+    switch (name) {
+      case "Write":
+        return { action: "Creating file", parameter: String(params.file_path ?? "") };
+      case "Edit":
+        return { action: "Editing file", parameter: String(params.file_path ?? "") };
+      case "Read":
+        return { action: "Reading file", parameter: String(params.file_path ?? "") };
+      case "Bash": {
+        const cmd = String(params.command ?? "");
+        return { action: "Running command", parameter: cmd.length > 80 ? cmd.substring(0, 80) + "..." : cmd };
+      }
+      case "Grep":
+        return { action: "Searching", parameter: String(params.pattern ?? "") };
+      case "Glob":
+        return { action: "Finding files", parameter: String(params.pattern ?? "") };
+      case "Task":
+        return { action: "Delegating", parameter: String(params.subagent_type ?? "subagent") };
+      case "Skill":
+        return { action: "Using skill", parameter: String(params.skill ?? "") };
+      default:
+        return { action: name, parameter: JSON.stringify(params).substring(0, 100) };
+    }
+  }
+  mapStatusToLinear(status) {
+    switch (status) {
+      case "in_progress":
+        return "inProgress";
+      case "completed":
+        return "completed";
+      case "canceled":
+        return "canceled";
+      case "pending":
+      default:
+        return "pending";
+    }
+  }
+};
+var createLinearAgent = (sessionId) => {
+  const linearAccessToken = process.env.LINEAR_ACCESS_TOKEN;
+  if (!linearAccessToken) {
+    throw new Error("Linear access token is missing");
+  }
+  return new LinearAgent({ linearAccessToken, linearSessionId: sessionId });
+};
+
+// src/factory.ts
+function createAgent(platform, sessionId) {
+  switch (platform) {
+    case "linear" /* Linear */:
+      return createLinearAgent(sessionId);
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+// src/callback.ts
+async function sendSessionUpdate(callbackUrl, callbackSecret, update) {
+  try {
+    const response = await fetch(callbackUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${callbackSecret}`
+      },
+      body: JSON.stringify(update)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      console.error(`[callback] Failed: ${response.status} ${response.statusText} - ${body}`);
+    }
+  } catch (error) {
+    console.error("[callback] Failed to send session update:", error);
+  }
+}
+async function reportResult(callbackUrl, externalSessionId, result) {
+  const callbackSecret = process.env.CLAUDE_LINEAR_CALLBACK_SECRET;
+  if (!callbackUrl || !callbackSecret) {
+    return;
+  }
+  if (result.sessionId) {
+    await sendSessionUpdate(callbackUrl, callbackSecret, {
+      externalSessionId,
+      claudeSessionId: result.sessionId,
+      state: "running" /* Running */
+    });
+  }
+  if (result.error) {
+    await sendSessionUpdate(callbackUrl, callbackSecret, {
+      externalSessionId,
+      state: "error" /* Error */,
+      error: result.error
+    });
+  } else if (!result.interrupted) {
+    await sendSessionUpdate(callbackUrl, callbackSecret, {
+      externalSessionId,
+      claudeSessionId: result.sessionId,
+      state: "completed" /* Completed */
+    });
+  }
+}
+
+// src/commands/start.ts
+var startCommand = new Command("start").description("Start a new agent session").requiredOption("--platform <platform>", "Platform type (linear)").requiredOption("--session-id <id>", "External session ID (e.g., Linear session ID)").requiredOption("--prompt <prompt>", "Initial prompt for the agent").option("--callback-url <url>", "Server callback URL for session updates").option("--working-dir <dir>", "Working directory", process.cwd()).action(async (options) => {
+  const { platform, sessionId, prompt, callbackUrl, workingDir } = options;
+  try {
+    console.log(`[CLI.start] sessionId=${sessionId} | cwd=${workingDir}`);
+    console.log(`[CLI.start] prompt=${prompt.substring(0, 300)}...`);
+    const agent = createAgent(platform, sessionId);
+    const result = await agent.run({
+      prompt,
+      cwd: workingDir
+    });
+    await reportResult(callbackUrl, sessionId, result);
+    console.log(JSON.stringify({
+      status: result.error ? "error" : result.interrupted ? "interrupted" : "completed",
+      claudeSessionId: result.sessionId,
+      result: result.result,
+      error: result.error
+    }));
+    process.exit(result.error ? 1 : 0);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    await reportResult(callbackUrl, sessionId, { sessionId: "", error: errorMessage });
+    console.error(JSON.stringify({ status: "error", error: errorMessage }));
+    process.exit(1);
+  }
+});
+var start_default = startCommand;
+
+// src/commands/stop.ts
+import { Command as Command2 } from "commander";
+var stopCommand = new Command2("stop").description("Stop an agent session gracefully").requiredOption("--platform <platform>", "Platform type (linear)").requiredOption("--session-id <id>", "External session ID (e.g., Linear session ID)").action(async (options) => {
+  const { platform, sessionId } = options;
+  try {
+    const agent = createAgent(platform, sessionId);
+    await agent.stop();
+    console.log(JSON.stringify({
+      status: "stopped",
+      sessionId
+    }));
+    process.exit(0);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(JSON.stringify({
+      status: "error",
+      error: errorMessage
+    }));
+    process.exit(1);
+  }
+});
+
+// src/commands/resume.ts
+import { Command as Command3 } from "commander";
+var resumeCommand = new Command3("resume").description("Resume an existing agent session").requiredOption("--platform <platform>", "Platform type (linear)").requiredOption("--session-id <id>", "External session ID (e.g., Linear session ID)").requiredOption("--claude-session-id <id>", "Claude SDK session ID to resume").requiredOption("--prompt <prompt>", "New prompt/user input").option("--callback-url <url>", "Server callback URL for session updates").option("--working-dir <dir>", "Working directory", process.cwd()).action(async (options) => {
+  const { platform, sessionId, claudeSessionId, prompt, callbackUrl, workingDir } = options;
+  const agent = createAgent(platform, sessionId);
+  try {
+    console.log(`[CLI.resume] sessionId=${sessionId} | claudeSessionId=${claudeSessionId} | cwd=${workingDir}`);
+    const result = await agent.run({
+      prompt,
+      sessionId: claudeSessionId,
+      resumeSession: true,
+      forkSession: false,
+      cwd: workingDir
+    });
+    await reportResult(callbackUrl, sessionId, result);
+    console.log(JSON.stringify({
+      status: result.error ? "error" : result.interrupted ? "interrupted" : "completed",
+      claudeSessionId: result.sessionId,
+      result: result.result,
+      error: result.error
+    }));
+    process.exit(result.error ? 1 : 0);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(JSON.stringify({ status: "error", error: errorMessage }));
+    process.exit(1);
+  }
+});
+
+// src/commands/init.ts
+import { Command as Command4 } from "commander";
+var initCommand = new Command4("init").description("Install agent plugin (MCP servers, skills)").action(() => {
+  installClaudeConfig();
+});
+
+// src/commands/update.ts
+import { Command as Command5 } from "commander";
+import { execSync, execFileSync } from "child_process";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2, join as join3 } from "path";
+function getCurrentPackageName() {
+  try {
+    const __filename = fileURLToPath2(import.meta.url);
+    const __dirname = dirname2(__filename);
+    const packageJsonPath = join3(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+    return packageJson.name;
+  } catch (error) {
+    console.warn("Could not determine package name, defaulting to kartman");
+    return "kartman";
+  }
+}
+function buildInstallArgs(cliPackage, cliVersion) {
+  if (!["kartman", "kartman-dev"].includes(cliPackage)) {
+    throw new Error(`Invalid package name: ${cliPackage}. Must be 'kartman' or 'kartman-dev'`);
+  }
+  if (cliVersion && !/^[\w.-]+$/.test(cliVersion)) {
+    throw new Error(`Invalid version format: ${cliVersion}`);
+  }
+  if (!cliVersion) {
+    return ["pnpm", "add", "-g", `${cliPackage}@latest`];
+  }
+  if (cliVersion.match(/^\d+\.\d+\.\d+/)) {
+    return ["pnpm", "add", "-g", `${cliPackage}@${cliVersion}`];
+  }
+  if (cliPackage === "kartman-dev") {
+    try {
+      const currentVersion = execSync("kartman --version", { encoding: "utf-8" }).trim();
+      const baseVersion = currentVersion.replace(/-dev\..+$/, "");
+      return ["pnpm", "add", "-g", `${cliPackage}@${baseVersion}-dev.${cliVersion}`];
+    } catch {
+      return ["pnpm", "add", "-g", `${cliPackage}@latest`];
+    }
+  }
+  return ["pnpm", "add", "-g", `${cliPackage}@${cliVersion}`];
+}
+var updateCommand = new Command5().name("update").description("Update kartman CLI to the latest version").option("--version <version>", 'Specific version to install (e.g., "KAR-14" for kartman-dev@0.2.10-dev.KAR-14)').action(async (options) => {
+  const { version } = options;
+  const packageName = getCurrentPackageName();
+  try {
+    const installArgs = buildInstallArgs(packageName, version);
+    console.log(`Updating CLI: ${installArgs.join(" ")}`);
+    const [cmd, ...args] = installArgs;
+    if (!cmd) {
+      throw new Error("Invalid install command");
+    }
+    execFileSync(cmd, args, {
+      stdio: "inherit",
+      encoding: "utf-8"
+    });
+    const newVersion = execSync("kartman --version", { encoding: "utf-8" }).trim();
+    console.log(`Current version: ${newVersion}`);
+    console.log("\u2713 CLI updated successfully");
+  } catch (error) {
+    console.error("Failed to update CLI:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command6();
+program.name("kartman").description("CLI for running Claude agents in Vercel sandboxes").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(start_default);
+program.addCommand(stopCommand);
+program.addCommand(resumeCommand);
+program.addCommand(updateCommand);
+program.parse();
+//# sourceMappingURL=index.js.map