@artyfacts/claude 1.1.0 → 1.1.2

package/dist/chunk-4RRGLYN6.mjs

@@ -0,0 +1,567 @@
+// src/auth.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+var CREDENTIALS_DIR = path.join(os.homedir(), ".artyfacts");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+var DEFAULT_BASE_URL = "https://artyfacts.dev/api/v1";
+function loadCredentials() {
+  try {
+    if (!fs.existsSync(CREDENTIALS_FILE)) {
+      return null;
+    }
+    const data = fs.readFileSync(CREDENTIALS_FILE, "utf-8");
+    const credentials = JSON.parse(data);
+    if (credentials.expiresAt) {
+      const expiresAt = new Date(credentials.expiresAt);
+      if (expiresAt < /* @__PURE__ */ new Date()) {
+        console.log("\u26A0\uFE0F  Credentials have expired");
+        return null;
+      }
+    }
+    return credentials;
+  } catch (error) {
+    console.error("Failed to load credentials:", error);
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  try {
+    if (!fs.existsSync(CREDENTIALS_DIR)) {
+      fs.mkdirSync(CREDENTIALS_DIR, { mode: 448, recursive: true });
+    }
+    fs.writeFileSync(
+      CREDENTIALS_FILE,
+      JSON.stringify(credentials, null, 2),
+      { mode: 384 }
+    );
+  } catch (error) {
+    throw new Error(`Failed to save credentials: ${error}`);
+  }
+}
+function clearCredentials() {
+  try {
+    if (fs.existsSync(CREDENTIALS_FILE)) {
+      fs.unlinkSync(CREDENTIALS_FILE);
+    }
+  } catch (error) {
+    console.error("Failed to clear credentials:", error);
+  }
+}
+async function runDeviceAuth(baseUrl = DEFAULT_BASE_URL) {
+  console.log("\u{1F510} Starting device authentication...\n");
+  const deviceAuth = await requestDeviceCode(baseUrl);
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  console.log("\u{1F4CB} To authenticate, visit:");
+  console.log(`   ${deviceAuth.verificationUri}`);
+  console.log("");
+  console.log("\u{1F511} Enter this code:");
+  console.log(`   ${deviceAuth.userCode}`);
+  console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
+  console.log("\u23F3 Waiting for authentication...\n");
+  const credentials = await pollForToken(
+    baseUrl,
+    deviceAuth.deviceCode,
+    deviceAuth.interval,
+    deviceAuth.expiresIn
+  );
+  saveCredentials(credentials);
+  console.log("\u2705 Authentication successful!");
+  console.log(`   Agent ID: ${credentials.agentId}`);
+  if (credentials.agentName) {
+    console.log(`   Agent Name: ${credentials.agentName}`);
+  }
+  console.log("");
+  return credentials;
+}
+async function requestDeviceCode(baseUrl) {
+  const response = await fetch(`${baseUrl}/auth/device`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      client_id: "artyfacts-claude",
+      scope: "agent:execute"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to start device auth: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    deviceCode: data.deviceCode || data.device_code || "",
+    userCode: data.userCode || data.user_code || "",
+    verificationUri: data.verificationUri || data.verification_uri || `https://artyfacts.dev/auth/device`,
+    expiresIn: data.expiresIn || data.expires_in || 600,
+    interval: data.interval || 5
+  };
+}
+async function pollForToken(baseUrl, deviceCode, interval, expiresIn) {
+  const startTime = Date.now();
+  const timeoutMs = expiresIn * 1e3;
+  while (true) {
+    if (Date.now() - startTime > timeoutMs) {
+      throw new Error("Device authentication timed out");
+    }
+    await sleep(interval * 1e3);
+    const response = await fetch(`${baseUrl}/auth/device/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        device_code: deviceCode,
+        client_id: "artyfacts-claude"
+      })
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return {
+        apiKey: data.apiKey,
+        agentId: data.agentId,
+        agentName: data.agentName,
+        expiresAt: data.expiresAt
+      };
+    }
+    const errorData = await response.json().catch(() => ({}));
+    const errorCode = errorData.error || errorData.code;
+    if (errorCode === "authorization_pending") {
+      process.stdout.write(".");
+      continue;
+    }
+    if (errorCode === "slow_down") {
+      interval = Math.min(interval * 2, 30);
+      continue;
+    }
+    if (errorCode === "expired_token") {
+      throw new Error("Device code expired. Please try again.");
+    }
+    if (errorCode === "access_denied") {
+      throw new Error("Authorization was denied.");
+    }
+    throw new Error(`Authentication failed: ${errorData.message || errorCode || response.statusText}`);
+  }
+}
+async function promptForApiKey() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const question = (prompt) => {
+    return new Promise((resolve) => {
+      rl.question(prompt, resolve);
+    });
+  };
+  console.log("\u{1F511} Manual Configuration\n");
+  console.log("Enter your Artyfacts credentials:\n");
+  const apiKey = await question("API Key: ");
+  const agentId = await question("Agent ID: ");
+  const agentName = await question("Agent Name (optional): ");
+  rl.close();
+  if (!apiKey || !agentId) {
+    throw new Error("API Key and Agent ID are required");
+  }
+  const credentials = {
+    apiKey: apiKey.trim(),
+    agentId: agentId.trim(),
+    agentName: agentName.trim() || void 0
+  };
+  saveCredentials(credentials);
+  console.log("\n\u2705 Credentials saved!");
+  return credentials;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function getCredentials(options) {
+  if (!options?.forceAuth) {
+    const existing = loadCredentials();
+    if (existing) {
+      return existing;
+    }
+  }
+  return runDeviceAuth(options?.baseUrl);
+}
+
+// src/executor.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT = 5 * 60 * 1e3;
+var DEFAULT_SYSTEM_PROMPT = `You are an AI agent working within the Artyfacts task management system.
+
+Your job is to complete tasks assigned to you. For each task:
+1. Understand the requirements from the task heading and content
+2. Complete the task to the best of your ability
+3. Provide a clear, actionable output
+
+Guidelines:
+- Be thorough but concise
+- If the task requires code, provide working code
+- If the task requires analysis, provide structured findings
+- If the task requires a decision, explain your reasoning
+- If you cannot complete the task, explain why
+
+Format your response as follows:
+1. First, provide your main output (the task deliverable)
+2. End with a brief summary line starting with "SUMMARY:"`;
+var ClaudeExecutor = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      ...config,
+      timeout: config.timeout || DEFAULT_TIMEOUT,
+      claudePath: config.claudePath || "claude"
+    };
+  }
+  /**
+   * Execute a task using Claude Code CLI
+   */
+  async execute(task) {
+    try {
+      const prompt = this.buildTaskPrompt(task);
+      const output = await this.runClaude(prompt);
+      const { content, summary } = this.parseResponse(output, task.heading);
+      return {
+        success: true,
+        output: content,
+        summary
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: "",
+        summary: `Failed: ${errorMessage}`,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Run Claude Code CLI with the given prompt
+   */
+  runClaude(prompt) {
+    return new Promise((resolve, reject) => {
+      const claudePath = this.config.claudePath || "claude";
+      const proc = spawn(claudePath, ["--print"], {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: this.config.timeout
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout.trim());
+        } else {
+          reject(new Error(stderr || `Claude exited with code ${code}`));
+        }
+      });
+      proc.on("error", (err) => {
+        if (err.code === "ENOENT") {
+          reject(new Error(
+            "Claude Code CLI not found. Please install it:\n  npm install -g @anthropic-ai/claude-code"
+          ));
+        } else {
+          reject(err);
+        }
+      });
+      proc.stdin.write(prompt);
+      proc.stdin.end();
+    });
+  }
+  /**
+   * Build the task prompt
+   */
+  buildTaskPrompt(task) {
+    const parts = [];
+    const systemPrompt = this.config.systemPromptPrefix ? `${this.config.systemPromptPrefix}
+
+${DEFAULT_SYSTEM_PROMPT}` : DEFAULT_SYSTEM_PROMPT;
+    parts.push(systemPrompt);
+    parts.push("");
+    parts.push("---");
+    parts.push("");
+    parts.push(`# Task: ${task.heading}`);
+    parts.push("");
+    if (task.artifactTitle) {
+      parts.push(`**Artifact:** ${task.artifactTitle}`);
+    }
+    if (task.priority) {
+      const priorityLabels = ["High", "Medium", "Low"];
+      parts.push(`**Priority:** ${priorityLabels[task.priority - 1] || "Medium"}`);
+    }
+    parts.push("");
+    parts.push("## Description");
+    parts.push(task.content || "No additional description provided.");
+    parts.push("");
+    if (task.context && Object.keys(task.context).length > 0) {
+      parts.push("## Additional Context");
+      parts.push("```json");
+      parts.push(JSON.stringify(task.context, null, 2));
+      parts.push("```");
+      parts.push("");
+    }
+    parts.push("## Instructions");
+    parts.push("Complete this task and provide your output below.");
+    return parts.join("\n");
+  }
+  /**
+   * Parse the response to extract output and summary
+   */
+  parseResponse(fullOutput, taskHeading) {
+    const summaryMatch = fullOutput.match(/SUMMARY:\s*(.+?)(?:\n|$)/i);
+    if (summaryMatch) {
+      const summary2 = summaryMatch[1].trim();
+      const content = fullOutput.replace(/SUMMARY:\s*.+?(?:\n|$)/i, "").trim();
+      return { content, summary: summary2 };
+    }
+    const lines = fullOutput.split("\n").filter((l) => l.trim());
+    const firstLine = lines[0] || "";
+    const summary = firstLine.length > 100 ? `${firstLine.substring(0, 97)}...` : firstLine || `Completed: ${taskHeading}`;
+    return { content: fullOutput, summary };
+  }
+  /**
+   * Test that Claude Code CLI is available and working
+   */
+  async testConnection() {
+    try {
+      const output = await this.runClaude('Say "connected" and nothing else.');
+      return output.toLowerCase().includes("connected");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if Claude Code CLI is installed
+   */
+  async isInstalled() {
+    return new Promise((resolve) => {
+      const proc = spawn(this.config.claudePath || "claude", ["--version"], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      proc.on("close", (code) => {
+        resolve(code === 0);
+      });
+      proc.on("error", () => {
+        resolve(false);
+      });
+    });
+  }
+};
+function createExecutor(config) {
+  return new ClaudeExecutor(config);
+}
+
+// src/listener.ts
+import EventSource from "eventsource";
+var DEFAULT_BASE_URL2 = "https://artyfacts.dev/api/v1";
+var EVENT_TYPES = [
+  "connected",
+  "heartbeat",
+  "task_assigned",
+  "task_unblocked",
+  "blocker_resolved",
+  "notification"
+];
+var ArtyfactsListener = class {
+  config;
+  eventSource = null;
+  callbacks = /* @__PURE__ */ new Map();
+  allCallbacks = /* @__PURE__ */ new Set();
+  state = "disconnected";
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectDelay = 1e3;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!config.agentId) {
+      throw new Error("Agent ID is required");
+    }
+    this.config = {
+      ...config,
+      baseUrl: config.baseUrl || DEFAULT_BASE_URL2
+    };
+  }
+  /**
+   * Get current connection state
+   */
+  get connectionState() {
+    return this.state;
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.state === "connected";
+  }
+  /**
+   * Subscribe to all events
+   */
+  subscribe(callback) {
+    this.allCallbacks.add(callback);
+    return () => {
+      this.allCallbacks.delete(callback);
+    };
+  }
+  /**
+   * Subscribe to a specific event type
+   */
+  on(type, callback) {
+    if (!this.callbacks.has(type)) {
+      this.callbacks.set(type, /* @__PURE__ */ new Set());
+    }
+    this.callbacks.get(type).add(callback);
+    return () => {
+      const typeCallbacks = this.callbacks.get(type);
+      if (typeCallbacks) {
+        typeCallbacks.delete(callback);
+        if (typeCallbacks.size === 0) {
+          this.callbacks.delete(type);
+        }
+      }
+    };
+  }
+  /**
+   * Connect to the SSE stream
+   */
+  connect() {
+    if (this.eventSource) {
+      return;
+    }
+    this.setState("connecting");
+    const url = new URL(`${this.config.baseUrl}/events/stream`);
+    url.searchParams.set("apiKey", this.config.apiKey);
+    url.searchParams.set("agentId", this.config.agentId);
+    this.eventSource = new EventSource(url.toString(), {
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`
+      }
+    });
+    this.eventSource.onopen = () => {
+      this.reconnectAttempts = 0;
+      this.reconnectDelay = 1e3;
+      this.setState("connected");
+    };
+    this.eventSource.onmessage = (event) => {
+      this.handleMessage(event);
+    };
+    this.eventSource.onerror = (event) => {
+      this.handleError(event);
+    };
+    for (const eventType of EVENT_TYPES) {
+      this.eventSource.addEventListener(eventType, (event) => {
+        this.handleMessage(event, eventType);
+      });
+    }
+  }
+  /**
+   * Disconnect from the SSE stream
+   */
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+    this.setState("disconnected");
+  }
+  /**
+   * Reconnect to the SSE stream
+   */
+  reconnect() {
+    this.disconnect();
+    this.connect();
+  }
+  /**
+   * Handle incoming SSE message
+   */
+  handleMessage(event, eventType) {
+    try {
+      const data = JSON.parse(event.data);
+      const artyfactsEvent = {
+        type: eventType || data.type || "unknown",
+        timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        data: data.data || data
+      };
+      const typeCallbacks = this.callbacks.get(artyfactsEvent.type);
+      if (typeCallbacks) {
+        for (const callback of typeCallbacks) {
+          this.safeCallCallback(callback, artyfactsEvent);
+        }
+      }
+      for (const callback of this.allCallbacks) {
+        this.safeCallCallback(callback, artyfactsEvent);
+      }
+    } catch (err) {
+      console.error("[Listener] Failed to parse SSE message:", event.data, err);
+    }
+  }
+  /**
+   * Safely call a callback, handling async and errors
+   */
+  async safeCallCallback(callback, event) {
+    try {
+      await callback(event);
+    } catch (err) {
+      console.error(`[Listener] Error in event callback for '${event.type}':`, err);
+    }
+  }
+  /**
+   * Handle SSE error
+   */
+  handleError(event) {
+    if (this.eventSource?.readyState === EventSource.CONNECTING) {
+      this.setState("reconnecting");
+    } else if (this.eventSource?.readyState === EventSource.CLOSED) {
+      this.setState("disconnected");
+      if (this.reconnectAttempts < this.maxReconnectAttempts) {
+        this.reconnectAttempts++;
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, 3e4);
+        console.log(
+          `[Listener] Connection lost, reconnecting in ${this.reconnectDelay / 1e3}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+        );
+        setTimeout(() => {
+          if (this.state === "disconnected") {
+            this.connect();
+          }
+        }, this.reconnectDelay);
+      } else {
+        const error = new Error("Max reconnection attempts reached");
+        this.config.onError?.(error);
+      }
+    }
+  }
+  /**
+   * Update connection state
+   */
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.config.onStateChange?.(state);
+    }
+  }
+};
+function createListener(config) {
+  return new ArtyfactsListener(config);
+}
+
+export {
+  loadCredentials,
+  saveCredentials,
+  clearCredentials,
+  runDeviceAuth,
+  promptForApiKey,
+  getCredentials,
+  ClaudeExecutor,
+  createExecutor,
+  ArtyfactsListener,
+  createListener
+};

package/dist/cli.js

@@ -120,10 +120,10 @@ async function requestDeviceCode(baseUrl) {
   }
   const data = await response.json();
   return {
-    deviceCode: data.device_code,
-    userCode: data.user_code,
-    verificationUri: data.verification_uri || `https://artyfacts.dev/auth/device`,
-    expiresIn: data.expires_in || 600,
+    deviceCode: data.deviceCode || data.device_code || "",
+    userCode: data.userCode || data.user_code || "",
+    verificationUri: data.verificationUri || data.verification_uri || `https://artyfacts.dev/auth/device`,
+    expiresIn: data.expiresIn || data.expires_in || 600,
     interval: data.interval || 5
   };
 }
@@ -637,6 +637,88 @@ program.command("status").description("Check authentication and connection statu
     console.log("   Install: npm install -g @anthropic-ai/claude-code");
   }
 });
+async function checkAndClaimTasks(baseUrl, apiKey, agentId, activeTasks, executor, dryRun) {
+  try {
+    const response = await fetch(`${baseUrl}/tasks/queue?limit=5`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      console.log("\u26A0\uFE0F  Could not fetch task queue");
+      return;
+    }
+    const data = await response.json();
+    const tasks = data.tasks || [];
+    if (tasks.length === 0) {
+      console.log("\u{1F4ED} No claimable tasks in queue");
+      return;
+    }
+    console.log(`\u{1F4EC} Found ${tasks.length} claimable task(s)`);
+    for (const task of tasks) {
+      if (activeTasks.has(task.section_id)) {
+        continue;
+      }
+      console.log(`
+[Claiming] ${task.heading}`);
+      const claimResponse = await fetch(`${baseUrl}/tasks/${task.section_id}/claim`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!claimResponse.ok) {
+        const error = await claimResponse.json().catch(() => ({}));
+        console.log(`  \u26A0\uFE0F  Could not claim: ${error.error || "Unknown error"}`);
+        continue;
+      }
+      activeTasks.add(task.section_id);
+      console.log("  \u2713 Claimed!");
+      if (dryRun) {
+        console.log("  \u{1F4CB} Dry run - not executing");
+        activeTasks.delete(task.section_id);
+        continue;
+      }
+      console.log("  \u2192 Executing with Claude...");
+      try {
+        const result = await executor.execute({
+          taskId: task.section_id,
+          heading: task.heading,
+          content: task.content,
+          artifactId: task.artifact_id,
+          artifactTitle: task.artifact_title,
+          priority: task.priority
+        });
+        if (result.success) {
+          await completeTask({
+            baseUrl,
+            apiKey,
+            taskId: task.section_id,
+            output: result.output,
+            summary: result.summary
+          });
+          console.log(`  \u2192 \u2705 Completed! ${result.summary}`);
+        } else {
+          console.log(`  \u2192 \u274C Failed: ${result.error}`);
+          await blockTask({
+            baseUrl,
+            apiKey,
+            taskId: task.section_id,
+            reason: result.error || "Execution failed"
+          });
+        }
+      } catch (error) {
+        console.error(`  \u2192 \u274C Error:`, error instanceof Error ? error.message : error);
+      } finally {
+        activeTasks.delete(task.section_id);
+      }
+      break;
+    }
+  } catch (error) {
+    console.error("Error checking task queue:", error instanceof Error ? error.message : error);
+  }
+}
 async function runAgent(options) {
   console.log("\u{1F517} Connecting to Artyfacts...");
   let credentials;
@@ -677,6 +759,7 @@ async function runAgent(options) {
         case "connected":
           console.log(`\u2705 Connected as ${credentials.agentId}`);
           console.log("\u{1F442} Listening for tasks...\n");
+          checkAndClaimTasks(options.baseUrl, credentials.apiKey, credentials.agentId, activeTasks, executor, options.dryRun);
           break;
         case "reconnecting":
           console.log("\u{1F504} Reconnecting...");

package/dist/cli.mjs

@@ -6,7 +6,7 @@ import {
   getCredentials,
   loadCredentials,
   promptForApiKey
-} from "./chunk-365PEWTO.mjs";
+} from "./chunk-4RRGLYN6.mjs";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -65,6 +65,88 @@ program.command("status").description("Check authentication and connection statu
     console.log("   Install: npm install -g @anthropic-ai/claude-code");
   }
 });
+async function checkAndClaimTasks(baseUrl, apiKey, agentId, activeTasks, executor, dryRun) {
+  try {
+    const response = await fetch(`${baseUrl}/tasks/queue?limit=5`, {
+      headers: {
+        "Authorization": `Bearer ${apiKey}`
+      }
+    });
+    if (!response.ok) {
+      console.log("\u26A0\uFE0F  Could not fetch task queue");
+      return;
+    }
+    const data = await response.json();
+    const tasks = data.tasks || [];
+    if (tasks.length === 0) {
+      console.log("\u{1F4ED} No claimable tasks in queue");
+      return;
+    }
+    console.log(`\u{1F4EC} Found ${tasks.length} claimable task(s)`);
+    for (const task of tasks) {
+      if (activeTasks.has(task.section_id)) {
+        continue;
+      }
+      console.log(`
+[Claiming] ${task.heading}`);
+      const claimResponse = await fetch(`${baseUrl}/tasks/${task.section_id}/claim`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!claimResponse.ok) {
+        const error = await claimResponse.json().catch(() => ({}));
+        console.log(`  \u26A0\uFE0F  Could not claim: ${error.error || "Unknown error"}`);
+        continue;
+      }
+      activeTasks.add(task.section_id);
+      console.log("  \u2713 Claimed!");
+      if (dryRun) {
+        console.log("  \u{1F4CB} Dry run - not executing");
+        activeTasks.delete(task.section_id);
+        continue;
+      }
+      console.log("  \u2192 Executing with Claude...");
+      try {
+        const result = await executor.execute({
+          taskId: task.section_id,
+          heading: task.heading,
+          content: task.content,
+          artifactId: task.artifact_id,
+          artifactTitle: task.artifact_title,
+          priority: task.priority
+        });
+        if (result.success) {
+          await completeTask({
+            baseUrl,
+            apiKey,
+            taskId: task.section_id,
+            output: result.output,
+            summary: result.summary
+          });
+          console.log(`  \u2192 \u2705 Completed! ${result.summary}`);
+        } else {
+          console.log(`  \u2192 \u274C Failed: ${result.error}`);
+          await blockTask({
+            baseUrl,
+            apiKey,
+            taskId: task.section_id,
+            reason: result.error || "Execution failed"
+          });
+        }
+      } catch (error) {
+        console.error(`  \u2192 \u274C Error:`, error instanceof Error ? error.message : error);
+      } finally {
+        activeTasks.delete(task.section_id);
+      }
+      break;
+    }
+  } catch (error) {
+    console.error("Error checking task queue:", error instanceof Error ? error.message : error);
+  }
+}
 async function runAgent(options) {
   console.log("\u{1F517} Connecting to Artyfacts...");
   let credentials;
@@ -105,6 +187,7 @@ async function runAgent(options) {
         case "connected":
           console.log(`\u2705 Connected as ${credentials.agentId}`);
           console.log("\u{1F442} Listening for tasks...\n");
+          checkAndClaimTasks(options.baseUrl, credentials.apiKey, credentials.agentId, activeTasks, executor, options.dryRun);
           break;
         case "reconnecting":
           console.log("\u{1F504} Reconnecting...");

package/dist/index.js

@@ -137,10 +137,10 @@ async function requestDeviceCode(baseUrl) {
   }
   const data = await response.json();
   return {
-    deviceCode: data.device_code,
-    userCode: data.user_code,
-    verificationUri: data.verification_uri || `https://artyfacts.dev/auth/device`,
-    expiresIn: data.expires_in || 600,
+    deviceCode: data.deviceCode || data.device_code || "",
+    userCode: data.userCode || data.user_code || "",
+    verificationUri: data.verificationUri || data.verification_uri || `https://artyfacts.dev/auth/device`,
+    expiresIn: data.expiresIn || data.expires_in || 600,
     interval: data.interval || 5
   };
 }

package/dist/index.mjs

@@ -9,7 +9,7 @@ import {
   promptForApiKey,
   runDeviceAuth,
   saveCredentials
-} from "./chunk-365PEWTO.mjs";
+} from "./chunk-4RRGLYN6.mjs";
 export {
   ArtyfactsListener,
   ClaudeExecutor,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artyfacts/claude",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Claude adapter for Artyfacts - Execute tasks using Claude Code CLI",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/auth.ts

@@ -179,18 +179,24 @@ async function requestDeviceCode(baseUrl: string): Promise<DeviceAuthResponse> {
   }
   
   const data = await response.json() as {
-    device_code: string;
-    user_code: string;
+    // API returns camelCase
+    deviceCode?: string;
+    userCode?: string;
+    verificationUri?: string;
+    expiresIn?: number;
+    interval?: number;
+    // Also accept snake_case for compatibility
+    device_code?: string;
+    user_code?: string;
     verification_uri?: string;
     expires_in?: number;
-    interval?: number;
   };
   
   return {
-    deviceCode: data.device_code,
-    userCode: data.user_code,
-    verificationUri: data.verification_uri || `https://artyfacts.dev/auth/device`,
-    expiresIn: data.expires_in || 600,
+    deviceCode: data.deviceCode || data.device_code || '',
+    userCode: data.userCode || data.user_code || '',
+    verificationUri: data.verificationUri || data.verification_uri || `https://artyfacts.dev/auth/device`,
+    expiresIn: data.expiresIn || data.expires_in || 600,
     interval: data.interval || 5,
   };
 }

package/src/cli.ts

@@ -126,6 +126,130 @@ program
     }
   });
 
+// ============================================================================
+// Task Queue Polling
+// ============================================================================
+
+/**
+ * Check for claimable tasks and process them
+ */
+async function checkAndClaimTasks(
+  baseUrl: string,
+  apiKey: string,
+  agentId: string,
+  activeTasks: Set<string>,
+  executor: ClaudeExecutor,
+  dryRun: boolean
+): Promise<void> {
+  try {
+    // Fetch claimable tasks from queue
+    const response = await fetch(`${baseUrl}/tasks/queue?limit=5`, {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      console.log('⚠️  Could not fetch task queue');
+      return;
+    }
+
+    const data = await response.json() as { tasks?: Array<{
+      id: string;
+      section_id: string;
+      heading: string;
+      content: string;
+      artifact_id: string;
+      artifact_title?: string;
+      priority?: number;
+    }> };
+
+    const tasks = data.tasks || [];
+    
+    if (tasks.length === 0) {
+      console.log('📭 No claimable tasks in queue');
+      return;
+    }
+
+    console.log(`📬 Found ${tasks.length} claimable task(s)`);
+
+    // Process first available task
+    for (const task of tasks) {
+      if (activeTasks.has(task.section_id)) {
+        continue; // Already processing
+      }
+
+      // Try to claim the task
+      console.log(`\n[Claiming] ${task.heading}`);
+      
+      const claimResponse = await fetch(`${baseUrl}/tasks/${task.section_id}/claim`, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+      });
+
+      if (!claimResponse.ok) {
+        const error = await claimResponse.json().catch(() => ({})) as { error?: string };
+        console.log(`  ⚠️  Could not claim: ${error.error || 'Unknown error'}`);
+        continue;
+      }
+
+      // Successfully claimed - now execute
+      activeTasks.add(task.section_id);
+      console.log('  ✓ Claimed!');
+
+      if (dryRun) {
+        console.log('  📋 Dry run - not executing');
+        activeTasks.delete(task.section_id);
+        continue;
+      }
+
+      console.log('  → Executing with Claude...');
+
+      try {
+        const result = await executor.execute({
+          taskId: task.section_id,
+          heading: task.heading,
+          content: task.content,
+          artifactId: task.artifact_id,
+          artifactTitle: task.artifact_title,
+          priority: task.priority,
+        });
+
+        if (result.success) {
+          await completeTask({
+            baseUrl,
+            apiKey,
+            taskId: task.section_id,
+            output: result.output,
+            summary: result.summary,
+          });
+          console.log(`  → ✅ Completed! ${result.summary}`);
+        } else {
+          console.log(`  → ❌ Failed: ${result.error}`);
+          await blockTask({
+            baseUrl,
+            apiKey,
+            taskId: task.section_id,
+            reason: result.error || 'Execution failed',
+          });
+        }
+      } catch (error) {
+        console.error(`  → ❌ Error:`, error instanceof Error ? error.message : error);
+      } finally {
+        activeTasks.delete(task.section_id);
+      }
+
+      // Only process one task at a time for now
+      break;
+    }
+  } catch (error) {
+    console.error('Error checking task queue:', error instanceof Error ? error.message : error);
+  }
+}
+
 // ============================================================================
 // Main Agent Loop
 // ============================================================================
@@ -183,6 +307,9 @@ async function runAgent(options: {
         case 'connected':
           console.log(`✅ Connected as ${credentials.agentId}`);
           console.log('👂 Listening for tasks...\n');
+          
+          // Check for existing claimable tasks on connect
+          checkAndClaimTasks(options.baseUrl, credentials.apiKey, credentials.agentId, activeTasks, executor!, options.dryRun);
           break;
         case 'reconnecting':
           console.log('🔄 Reconnecting...');