@artyfacts/claude 1.0.0 → 1.1.0

package/dist/cli.mjs

@@ -1,756 +1,219 @@
 #!/usr/bin/env node
+import {
+  clearCredentials,
+  createExecutor,
+  createListener,
+  getCredentials,
+  loadCredentials,
+  promptForApiKey
+} from "./chunk-365PEWTO.mjs";
 
 // 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}`);
+var VERSION = "0.1.0";
+var DEFAULT_BASE_URL = "https://artyfacts.dev/api/v1";
+var program = new Command();
+program.name("artyfacts-claude").description("Claude adapter for Artyfacts - Execute tasks using Claude API").version(VERSION);
+program.command("run", { isDefault: true }).description("Start listening for and executing tasks").option("--base-url <url>", "Artyfacts API base URL", DEFAULT_BASE_URL).option("--dry-run", "Print tasks but do not execute", false).action(async (options) => {
+  await runAgent(options);
+});
+program.command("login").description("Authenticate with Artyfacts").option("--manual", "Enter credentials manually instead of device auth").option("--base-url <url>", "Artyfacts API base URL", DEFAULT_BASE_URL).action(async (options) => {
+  try {
+    if (options.manual) {
+      await promptForApiKey();
+    } else {
+      await getCredentials({ baseUrl: options.baseUrl, forceAuth: true });
     }
-    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
-      })
-    });
+  } catch (error) {
+    console.error("\u274C Authentication failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
   }
-  /**
-   * Get current user/org info
-   */
-  async getMe() {
-    return this.fetch("/me");
+});
+program.command("logout").description("Clear stored credentials").action(() => {
+  clearCredentials();
+  console.log("\u2705 Credentials cleared");
+});
+program.command("status").description("Check authentication and connection status").action(async () => {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log("\u274C Not authenticated");
+    console.log("   Run: npx @artyfacts/claude login");
+    process.exit(1);
   }
-};
-
-// 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
-    };
+  console.log("\u2705 Authenticated");
+  console.log(`   Agent ID: ${credentials.agentId}`);
+  if (credentials.agentName) {
+    console.log(`   Agent Name: ${credentials.agentName}`);
   }
-  /**
-   * Check if Claude Code is installed and authenticated
-   */
-  async checkInstalled() {
+  const executor = createExecutor();
+  const installed = await executor.isInstalled();
+  if (installed) {
+    console.log("\u2705 Claude Code CLI installed");
     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 };
+      const connected = await executor.testConnection();
+      if (connected) {
+        console.log("\u2705 Claude Code authenticated and working");
+      } else {
+        console.log("\u26A0\uFE0F  Claude Code not authenticated");
+        console.log("   Run: claude login");
+      }
     } 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);
+      console.log("\u26A0\uFE0F  Claude Code error:", error instanceof Error ? error.message : error);
     }
-    this.running = true;
-    this.emit("started");
-    await this.poll();
-    this.pollTimer = setInterval(() => {
-      this.poll().catch((err) => this.emit("error", err));
-    }, this.config.pollIntervalMs);
+  } else {
+    console.log("\u274C Claude Code CLI not installed");
+    console.log("   Install: npm install -g @anthropic-ai/claude-code");
   }
-  /**
-   * 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");
+});
+async function runAgent(options) {
+  console.log("\u{1F517} Connecting to Artyfacts...");
+  let credentials;
+  try {
+    credentials = await getCredentials({ baseUrl: options.baseUrl });
+  } catch (error) {
+    console.error("\u274C Authentication failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
   }
-  /**
-   * 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);
+  let executor = null;
+  if (!options.dryRun) {
+    executor = createExecutor();
+    const installed = await executor.isInstalled();
+    if (!installed) {
+      console.error("\u274C Claude Code CLI not found");
+      console.error("   Install it with: npm install -g @anthropic-ai/claude-code");
+      console.error("   Then authenticate with: claude login");
+      process.exit(1);
+    }
+    console.log("\u{1F504} Testing Claude Code connection...");
+    const connected = await executor.testConnection();
+    if (!connected) {
+      console.error("\u274C Claude Code not authenticated");
+      console.error("   Run: claude login");
+      process.exit(1);
+    }
+    console.log("\u2705 Claude Code connected");
+  }
+  const listener = createListener({
+    apiKey: credentials.apiKey,
+    agentId: credentials.agentId,
+    baseUrl: options.baseUrl,
+    onStateChange: (state) => {
+      switch (state) {
+        case "connecting":
+          console.log("\u{1F504} Connecting...");
+          break;
+        case "connected":
+          console.log(`\u2705 Connected as ${credentials.agentId}`);
+          console.log("\u{1F442} Listening for tasks...\n");
+          break;
+        case "reconnecting":
+          console.log("\u{1F504} Reconnecting...");
+          break;
+        case "disconnected":
+          console.log("\u26A0\uFE0F  Disconnected");
+          break;
       }
-    } catch (error) {
-      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+    },
+    onError: (error) => {
+      console.error("\u274C Connection error:", error.message);
     }
-  }
-  /**
-   * Execute a single task
-   */
-  async executeTask(task) {
+  });
+  const activeTasks = /* @__PURE__ */ new Set();
+  listener.on("task_assigned", async (event) => {
+    const task = event.data;
+    if (activeTasks.has(task.taskId)) {
+      return;
+    }
+    activeTasks.add(task.taskId);
+    console.log(`
+[Task received] ${task.heading}`);
+    if (options.dryRun) {
+      console.log("  \u{1F4CB} Dry run - not executing");
+      console.log(`  \u{1F4C4} Artifact: ${task.artifactTitle || task.artifactId}`);
+      console.log(`  \u{1F4DD} Content: ${task.content.substring(0, 100)}...`);
+      activeTasks.delete(task.taskId);
+      return;
+    }
+    console.log("  \u2192 Executing with Claude...");
     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);
+      const taskContext = {
+        taskId: task.taskId,
+        heading: task.heading,
+        content: task.content,
+        artifactId: task.artifactId,
+        artifactTitle: task.artifactTitle,
+        priority: task.priority
+      };
+      const result = await executor.execute(taskContext);
       if (result.success) {
-        await this.client.completeTask(task.id, {
-          summary: this.extractSummary(result.output)
+        await completeTask({
+          baseUrl: options.baseUrl,
+          apiKey: credentials.apiKey,
+          taskId: task.taskId,
+          output: result.output,
+          summary: result.summary
         });
-        this.emit("task:completed", task, result);
+        console.log(`  \u2192 \u2705 Completed! ${result.summary}`);
       } else {
-        await this.client.blockTask(task.id, result.error ?? "Task failed");
-        this.emit("task:failed", task, result.error ?? "Unknown error");
+        console.log(`  \u2192 \u274C Failed: ${result.error}`);
+        await blockTask({
+          baseUrl: options.baseUrl,
+          apiKey: credentials.apiKey,
+          taskId: task.taskId,
+          reason: result.error || "Execution failed"
+        });
       }
     } catch (error) {
-      this.activeTasks.delete(task.id);
-      const message = error instanceof Error ? error.message : String(error);
-      this.emit("task:failed", task, message);
+      console.error(`  \u2192 \u274C Error:`, error instanceof Error ? error.message : error);
+    } finally {
+      activeTasks.delete(task.taskId);
     }
-  }
-  /**
-   * 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"));
+  listener.connect();
+  const shutdown = () => {
+    console.log("\n\u{1F44B} Disconnecting...");
+    listener.disconnect();
     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"));
+  await new Promise(() => {
+  });
+}
+async function completeTask(options) {
+  const response = await fetch(`${options.baseUrl}/tasks/${options.taskId}/complete`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      task_status: "done",
+      completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      summary: options.summary,
+      output: options.output
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to complete task: ${error}`);
   }
-});
-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"));
+}
+async function blockTask(options) {
+  const response = await fetch(`${options.baseUrl}/tasks/${options.taskId}/block`, {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      task_status: "blocked",
+      blocked_reason: options.reason
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to block task: ${error}`);
   }
-});
+}
 program.parse();