@artyfacts/claude 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,756 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+
+// src/adapter.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/artyfacts-client.ts
+var ArtyfactsClient = class {
+  config;
+  constructor(config) {
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? "https://artyfacts.dev/api/v1",
+      agentId: config.agentId ?? "claude-agent"
+    };
+  }
+  async fetch(path2, options = {}) {
+    const url = `${this.config.baseUrl}${path2}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        ...options.headers
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API error (${response.status}): ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get claimable tasks from the queue
+   */
+  async getTaskQueue(options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", options.limit.toString());
+    const result = await this.fetch(`/tasks/queue?${params}`);
+    return result.tasks;
+  }
+  /**
+   * Claim a task
+   */
+  async claimTask(taskId) {
+    return this.fetch(`/tasks/${taskId}/claim`, {
+      method: "POST",
+      body: JSON.stringify({ agent_id: this.config.agentId })
+    });
+  }
+  /**
+   * Complete a task
+   */
+  async completeTask(taskId, options) {
+    return this.fetch(`/tasks/${taskId}/complete`, {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.config.agentId,
+        output_url: options?.outputUrl,
+        summary: options?.summary
+      })
+    });
+  }
+  /**
+   * Report task as blocked
+   */
+  async blockTask(taskId, reason) {
+    await this.fetch(`/tasks/${taskId}/block`, {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.config.agentId,
+        reason
+      })
+    });
+  }
+  /**
+   * Get current user/org info
+   */
+  async getMe() {
+    return this.fetch("/me");
+  }
+};
+
+// src/claude-runner.ts
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+var ClaudeRunner = class extends EventEmitter {
+  config;
+  runningTasks = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this.config = {
+      claudePath: config.claudePath ?? "claude",
+      model: config.model ?? "sonnet",
+      cwd: config.cwd ?? process.cwd(),
+      timeoutMs: config.timeoutMs ?? 5 * 60 * 1e3
+      // 5 minutes
+    };
+  }
+  /**
+   * Check if Claude Code is installed and authenticated
+   */
+  async checkInstalled() {
+    try {
+      const result = await this.runCommand(["--version"]);
+      const version = result.output.trim();
+      const authCheck = await this.runCommand(["-p", 'Say "ok"', "--print", "--max-turns", "1"]);
+      const authenticated = authCheck.success && !authCheck.output.includes("not authenticated");
+      return { installed: true, authenticated, version };
+    } catch (error) {
+      return {
+        installed: false,
+        authenticated: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Run a task with Claude Code
+   */
+  async runTask(taskId, prompt, options) {
+    const startedAt = /* @__PURE__ */ new Date();
+    const model = options?.model ?? this.config.model;
+    const cwd = options?.cwd ?? this.config.cwd;
+    const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;
+    const args = [
+      "-p",
+      prompt,
+      "--print",
+      "--output-format",
+      "text",
+      "--model",
+      model
+    ];
+    this.emit("task:start", { taskId, prompt, model });
+    const promise = new Promise((resolve) => {
+      let output = "";
+      let error = "";
+      const proc = spawn(this.config.claudePath, args, {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env }
+      });
+      const timeout = setTimeout(() => {
+        proc.kill("SIGTERM");
+        resolve({
+          success: false,
+          output,
+          error: "Task timed out",
+          exitCode: null,
+          durationMs: Date.now() - startedAt.getTime()
+        });
+      }, timeoutMs);
+      proc.stdout?.on("data", (data) => {
+        output += data.toString();
+        this.emit("task:output", { taskId, chunk: data.toString() });
+      });
+      proc.stderr?.on("data", (data) => {
+        error += data.toString();
+      });
+      proc.on("close", (code) => {
+        clearTimeout(timeout);
+        this.runningTasks.delete(taskId);
+        const result = {
+          success: code === 0,
+          output: output.trim(),
+          error: error.trim() || void 0,
+          exitCode: code,
+          durationMs: Date.now() - startedAt.getTime()
+        };
+        this.emit("task:complete", { taskId, result });
+        resolve(result);
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timeout);
+        this.runningTasks.delete(taskId);
+        resolve({
+          success: false,
+          output: "",
+          error: err.message,
+          exitCode: null,
+          durationMs: Date.now() - startedAt.getTime()
+        });
+      });
+      this.runningTasks.set(taskId, {
+        taskId,
+        process: proc,
+        startedAt,
+        promise
+      });
+    });
+    return promise;
+  }
+  /**
+   * Run a raw claude command
+   */
+  runCommand(args) {
+    return new Promise((resolve) => {
+      const startedAt = Date.now();
+      let output = "";
+      let error = "";
+      const proc = spawn(this.config.claudePath, args, {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      proc.stdout?.on("data", (data) => {
+        output += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        error += data.toString();
+      });
+      proc.on("close", (code) => {
+        resolve({
+          success: code === 0,
+          output: output.trim(),
+          error: error.trim() || void 0,
+          exitCode: code,
+          durationMs: Date.now() - startedAt
+        });
+      });
+      proc.on("error", (err) => {
+        resolve({
+          success: false,
+          output: "",
+          error: err.message,
+          exitCode: null,
+          durationMs: Date.now() - startedAt
+        });
+      });
+    });
+  }
+  /**
+   * Cancel a running task
+   */
+  cancelTask(taskId) {
+    const task = this.runningTasks.get(taskId);
+    if (task) {
+      task.process.kill("SIGTERM");
+      this.runningTasks.delete(taskId);
+      this.emit("task:cancelled", { taskId });
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get count of running tasks
+   */
+  getRunningCount() {
+    return this.runningTasks.size;
+  }
+  /**
+   * Cancel all running tasks
+   */
+  cancelAll() {
+    for (const [taskId] of this.runningTasks) {
+      this.cancelTask(taskId);
+    }
+  }
+};
+
+// src/adapter.ts
+var ClaudeAdapter = class extends EventEmitter2 {
+  config;
+  client;
+  runner;
+  running = false;
+  pollTimer = null;
+  activeTasks = /* @__PURE__ */ new Set();
+  constructor(config) {
+    super();
+    this.config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? "https://artyfacts.dev/api/v1",
+      agentId: config.agentId ?? "claude-agent",
+      pollIntervalMs: config.pollIntervalMs ?? 3e4,
+      maxConcurrent: config.maxConcurrent ?? 1,
+      model: config.model ?? "sonnet",
+      cwd: config.cwd ?? process.cwd()
+    };
+    this.client = new ArtyfactsClient({
+      apiKey: this.config.apiKey,
+      baseUrl: this.config.baseUrl,
+      agentId: this.config.agentId
+    });
+    this.runner = new ClaudeRunner({
+      model: this.config.model,
+      cwd: this.config.cwd
+    });
+    this.runner.on("task:output", (data) => this.emit("task:output", data));
+  }
+  /**
+   * Check if Claude Code is ready
+   */
+  async checkReady() {
+    const check = await this.runner.checkInstalled();
+    if (!check.installed) {
+      return {
+        ready: false,
+        error: "Claude Code is not installed. Run: npm install -g @anthropic-ai/claude-code"
+      };
+    }
+    if (!check.authenticated) {
+      return {
+        ready: false,
+        error: "Claude Code is not authenticated. Run: claude login"
+      };
+    }
+    return { ready: true };
+  }
+  /**
+   * Start the adapter
+   */
+  async start() {
+    if (this.running) return;
+    const { ready, error } = await this.checkReady();
+    if (!ready) {
+      throw new Error(error);
+    }
+    this.running = true;
+    this.emit("started");
+    await this.poll();
+    this.pollTimer = setInterval(() => {
+      this.poll().catch((err) => this.emit("error", err));
+    }, this.config.pollIntervalMs);
+  }
+  /**
+   * Stop the adapter
+   */
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.runner.cancelAll();
+    this.emit("stopped");
+  }
+  /**
+   * Poll for and execute tasks
+   */
+  async poll() {
+    try {
+      const available = this.config.maxConcurrent - this.activeTasks.size;
+      if (available <= 0) return;
+      const tasks = await this.client.getTaskQueue({ limit: available });
+      this.emit("poll", tasks);
+      for (const task of tasks) {
+        if (this.activeTasks.has(task.id)) continue;
+        if (this.activeTasks.size >= this.config.maxConcurrent) break;
+        await this.executeTask(task);
+      }
+    } catch (error) {
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Execute a single task
+   */
+  async executeTask(task) {
+    try {
+      const claim = await this.client.claimTask(task.id);
+      if (!claim.success) return;
+      this.activeTasks.add(task.id);
+      this.emit("task:claimed", task);
+      const prompt = this.buildPrompt(task);
+      this.emit("task:running", task);
+      const result = await this.runner.runTask(task.id, prompt, {
+        cwd: this.config.cwd
+      });
+      this.activeTasks.delete(task.id);
+      if (result.success) {
+        await this.client.completeTask(task.id, {
+          summary: this.extractSummary(result.output)
+        });
+        this.emit("task:completed", task, result);
+      } else {
+        await this.client.blockTask(task.id, result.error ?? "Task failed");
+        this.emit("task:failed", task, result.error ?? "Unknown error");
+      }
+    } catch (error) {
+      this.activeTasks.delete(task.id);
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit("task:failed", task, message);
+    }
+  }
+  /**
+   * Build a prompt for Claude from the task
+   */
+  buildPrompt(task) {
+    return `You are working on a task from Artyfacts.
+
+## Task: ${task.heading}
+
+## Context
+- Artifact: ${task.artifactTitle}
+- URL: ${task.artifactUrl}
+- Priority: ${task.priority === 1 ? "High" : task.priority === 2 ? "Medium" : "Low"}
+
+## Details
+${task.content}
+
+## Instructions
+Complete this task to the best of your ability. When finished, provide a brief summary of what you accomplished.
+
+If you cannot complete the task, explain why clearly.`;
+  }
+  /**
+   * Extract a summary from Claude's output
+   */
+  extractSummary(output) {
+    const maxLen = 500;
+    if (output.length <= maxLen) return output;
+    return "..." + output.slice(-maxLen);
+  }
+  /**
+   * Check if running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get stats
+   */
+  getStats() {
+    return {
+      running: this.running,
+      activeTasks: this.activeTasks.size,
+      maxConcurrent: this.config.maxConcurrent
+    };
+  }
+};
+
+// src/auth.ts
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var DeviceAuth = class {
+  baseUrl;
+  credentialsPath;
+  constructor(options) {
+    this.baseUrl = options?.baseUrl ?? "https://artyfacts.dev";
+    this.credentialsPath = path.join(os.homedir(), ".artyfacts", "credentials.json");
+  }
+  /**
+   * Check if we have stored credentials
+   */
+  hasCredentials() {
+    return fs.existsSync(this.credentialsPath);
+  }
+  /**
+   * Get stored credentials
+   */
+  getCredentials() {
+    if (!this.hasCredentials()) return null;
+    try {
+      const data = fs.readFileSync(this.credentialsPath, "utf-8");
+      const creds = JSON.parse(data);
+      if (creds.expiresAt && Date.now() > creds.expiresAt) {
+        return null;
+      }
+      return creds;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get access token (for API calls)
+   */
+  getAccessToken() {
+    const creds = this.getCredentials();
+    return creds?.accessToken ?? null;
+  }
+  /**
+   * Clear stored credentials (logout)
+   */
+  logout() {
+    if (fs.existsSync(this.credentialsPath)) {
+      fs.unlinkSync(this.credentialsPath);
+    }
+  }
+  /**
+   * Start device authorization flow
+   */
+  async startDeviceFlow() {
+    const response = await fetch(`${this.baseUrl}/api/v1/auth/device`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to start device flow: ${response.status}`);
+    }
+    return response.json();
+  }
+  /**
+   * Poll for token after user authorizes
+   */
+  async pollForToken(deviceCode, interval, expiresIn) {
+    const startTime = Date.now();
+    const expiresAt = startTime + expiresIn * 1e3;
+    while (Date.now() < expiresAt) {
+      await this.sleep(interval * 1e3);
+      const response = await fetch(`${this.baseUrl}/api/v1/auth/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ deviceCode })
+      });
+      if (response.ok) {
+        return response.json();
+      }
+      const data = await response.json().catch(() => ({}));
+      if (data.error === "authorization_pending") {
+        continue;
+      }
+      if (data.error === "slow_down") {
+        interval += 5;
+        continue;
+      }
+      if (data.error === "expired_token") {
+        throw new Error("Authorization expired. Please try again.");
+      }
+      if (data.error === "access_denied") {
+        throw new Error("Authorization denied by user.");
+      }
+      throw new Error(data.error ?? "Unknown error during authorization");
+    }
+    throw new Error("Authorization timed out. Please try again.");
+  }
+  /**
+   * Save credentials to disk
+   */
+  saveCredentials(token) {
+    const dir = path.dirname(this.credentialsPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const creds = {
+      ...token,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.writeFileSync(this.credentialsPath, JSON.stringify(creds, null, 2), {
+      mode: 384
+      // Only user can read/write
+    });
+  }
+  /**
+   * Open URL in browser
+   */
+  openBrowser(url) {
+    const platform = process.platform;
+    try {
+      if (platform === "darwin") {
+        execSync(`open "${url}"`);
+      } else if (platform === "win32") {
+        execSync(`start "" "${url}"`);
+      } else {
+        execSync(`xdg-open "${url}"`);
+      }
+    } catch {
+      console.log(`Please open this URL in your browser: ${url}`);
+    }
+  }
+  /**
+   * Full login flow
+   */
+  async login(options) {
+    const deviceCode = await this.startDeviceFlow();
+    options?.onDeviceCode?.(deviceCode);
+    this.openBrowser(deviceCode.verificationUri);
+    options?.onWaiting?.();
+    const token = await this.pollForToken(
+      deviceCode.deviceCode,
+      deviceCode.interval,
+      deviceCode.expiresIn
+    );
+    this.saveCredentials(token);
+    return token;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/cli.ts
+var program = new Command();
+program.name("artyfacts-claude").description("Run Artyfacts tasks with Claude Code").version("1.0.0");
+async function ensureLoggedIn(options = {}) {
+  const auth = new DeviceAuth({ baseUrl: options.baseUrl });
+  const token = auth.getAccessToken();
+  if (token) {
+    const creds = auth.getCredentials();
+    console.log(chalk.gray(`Logged in as ${creds?.user.email}`));
+    return token;
+  }
+  console.log(chalk.blue("\u{1F517} Opening browser to log in...\n"));
+  try {
+    const result = await auth.login({
+      onDeviceCode: (response) => {
+        console.log(chalk.white(`  ${response.verificationUri}`));
+        console.log();
+        console.log(chalk.gray(`  Your code: ${chalk.bold(response.userCode)}`));
+        console.log();
+      },
+      onWaiting: () => {
+        console.log(chalk.gray("  Waiting for authorization..."));
+      }
+    });
+    console.log();
+    console.log(chalk.green(`\u2713 Logged in as ${result.user.email}`));
+    return result.accessToken;
+  } catch (error) {
+    throw new Error(`Login failed: ${error instanceof Error ? error.message : error}`);
+  }
+}
+program.command("start", { isDefault: true }).description("Start the adapter (polls for tasks and executes with Claude Code)").option("-u, --base-url <url>", "Artyfacts API URL", "https://artyfacts.dev").option("-a, --agent-id <id>", "Agent ID for attribution", "claude-agent").option("-i, --interval <sec>", "Poll interval in seconds", "30").option("-c, --concurrent <n>", "Max concurrent tasks", "1").option("-m, --model <model>", "Claude model to use", "sonnet").option("-d, --cwd <dir>", "Working directory", process.cwd()).action(async (options) => {
+  console.log(chalk.blue("\u{1F680} Artyfacts + Claude Code\n"));
+  let apiKey;
+  try {
+    apiKey = await ensureLoggedIn({ baseUrl: options.baseUrl });
+  } catch (error) {
+    console.error(chalk.red(`${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+  console.log();
+  console.log(chalk.gray("Checking Claude Code..."));
+  const runner = new ClaudeRunner();
+  const check = await runner.checkInstalled();
+  if (!check.installed) {
+    console.error(chalk.red("\u2717 Claude Code not found\n"));
+    console.error(chalk.white("  Install it:"));
+    console.error(chalk.cyan("  npm install -g @anthropic-ai/claude-code\n"));
+    process.exit(1);
+  }
+  if (!check.authenticated) {
+    console.error(chalk.red("\u2717 Claude Code not authenticated\n"));
+    console.error(chalk.white("  Run:"));
+    console.error(chalk.cyan("  claude login\n"));
+    process.exit(1);
+  }
+  console.log(chalk.green(`\u2713 Claude Code ${check.version}`));
+  console.log();
+  const adapter = new ClaudeAdapter({
+    apiKey,
+    baseUrl: `${options.baseUrl}/api/v1`,
+    agentId: options.agentId,
+    pollIntervalMs: parseInt(options.interval) * 1e3,
+    maxConcurrent: parseInt(options.concurrent),
+    model: options.model,
+    cwd: options.cwd
+  });
+  adapter.on("started", () => {
+    console.log(chalk.green("\u2713 Started"));
+    console.log(chalk.gray(`  Polling every ${options.interval}s`));
+    console.log(chalk.gray(`  Model: ${options.model}`));
+    console.log();
+    console.log(chalk.blue("Waiting for tasks from artyfacts.dev..."));
+    console.log(chalk.gray("Create goals and tasks at https://artyfacts.dev\n"));
+  });
+  adapter.on("poll", (tasks) => {
+    if (tasks.length > 0) {
+      console.log(chalk.gray(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Found ${tasks.length} task(s)`));
+    }
+  });
+  adapter.on("task:claimed", (task) => {
+    console.log(chalk.yellow(`
+\u25B6 ${task.heading}`));
+    console.log(chalk.gray(`  From: ${task.artifactTitle}`));
+  });
+  adapter.on("task:running", () => {
+    console.log(chalk.blue(`  Running with Claude...`));
+  });
+  adapter.on("task:completed", (task, result) => {
+    console.log(chalk.green(`\u2713 Completed`));
+    console.log(chalk.gray(`  Duration: ${(result.durationMs / 1e3).toFixed(1)}s
+`));
+  });
+  adapter.on("task:failed", (task, error) => {
+    console.log(chalk.red(`\u2717 Failed: ${error}
+`));
+  });
+  adapter.on("error", (error) => {
+    console.error(chalk.red(`Error: ${error.message}`));
+  });
+  const shutdown = async () => {
+    console.log(chalk.gray("\nShutting down..."));
+    await adapter.stop();
+    console.log(chalk.green("Stopped"));
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await adapter.start();
+  } catch (error) {
+    console.error(chalk.red(`Failed to start: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+});
+program.command("login").description("Log in to Artyfacts").option("-u, --base-url <url>", "Artyfacts URL", "https://artyfacts.dev").action(async (options) => {
+  console.log(chalk.blue("\u{1F517} Logging in to Artyfacts...\n"));
+  try {
+    await ensureLoggedIn({ baseUrl: options.baseUrl });
+    console.log(chalk.green("\n\u2713 Ready to use!"));
+    console.log(chalk.gray("  Run: npx @artyfacts/claude"));
+  } catch (error) {
+    console.error(chalk.red(`${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+});
+program.command("logout").description("Log out of Artyfacts").action(() => {
+  const auth = new DeviceAuth();
+  auth.logout();
+  console.log(chalk.green("\u2713 Logged out"));
+});
+program.command("status").description("Check login and Claude Code status").action(async () => {
+  console.log(chalk.blue("Artyfacts + Claude Code Status\n"));
+  const auth = new DeviceAuth();
+  const creds = auth.getCredentials();
+  if (creds) {
+    console.log(chalk.green(`\u2713 Artyfacts: ${creds.user.email}`));
+  } else {
+    console.log(chalk.yellow("\u25CB Artyfacts: Not logged in"));
+    console.log(chalk.gray("  Run: npx @artyfacts/claude login"));
+  }
+  const runner = new ClaudeRunner();
+  const check = await runner.checkInstalled();
+  if (!check.installed) {
+    console.log(chalk.red("\u2717 Claude Code: Not installed"));
+    console.log(chalk.gray("  Run: npm install -g @anthropic-ai/claude-code"));
+  } else if (!check.authenticated) {
+    console.log(chalk.yellow(`\u25CB Claude Code: ${check.version} (not authenticated)`));
+    console.log(chalk.gray("  Run: claude login"));
+  } else {
+    console.log(chalk.green(`\u2713 Claude Code: ${check.version}`));
+  }
+  console.log();
+  if (creds && check.installed && check.authenticated) {
+    console.log(chalk.green("Ready! Run: npx @artyfacts/claude"));
+  }
+});
+program.command("whoami").description("Show current logged-in user").action(() => {
+  const auth = new DeviceAuth();
+  const creds = auth.getCredentials();
+  if (creds) {
+    console.log(`Email: ${creds.user.email}`);
+    if (creds.user.name) console.log(`Name: ${creds.user.name}`);
+    console.log(`Org: ${creds.user.orgId}`);
+  } else {
+    console.log("Not logged in");
+    console.log(chalk.gray("Run: npx @artyfacts/claude login"));
+  }
+});
+program.parse();