@artyfacts/claude 1.0.0 → 1.1.0

package/dist/index.js

@@ -30,597 +30,583 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  ArtyfactsClient: () => ArtyfactsClient,
-  ClaudeAdapter: () => ClaudeAdapter,
-  ClaudeRunner: () => ClaudeRunner,
-  DeviceAuth: () => DeviceAuth
+  ArtyfactsListener: () => ArtyfactsListener,
+  ClaudeExecutor: () => ClaudeExecutor,
+  clearCredentials: () => clearCredentials,
+  createExecutor: () => createExecutor,
+  createListener: () => createListener,
+  getCredentials: () => getCredentials,
+  loadCredentials: () => loadCredentials,
+  promptForApiKey: () => promptForApiKey,
+  runDeviceAuth: () => runDeviceAuth,
+  saveCredentials: () => saveCredentials
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/adapter.ts
-var import_events2 = require("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
+// src/auth.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var readline = __toESM(require("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;
       }
-    });
-    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`, {
+    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.device_code,
+    userCode: data.user_code,
+    verificationUri: data.verification_uri || `https://artyfacts.dev/auth/device`,
+    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({
-        agent_id: this.config.agentId,
-        output_url: options?.outputUrl,
-        summary: options?.summary
+        device_code: deviceCode,
+        client_id: "artyfacts-claude"
       })
     });
-  }
-  /**
-   * 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
-      })
+    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;
+    }
   }
-  /**
-   * Get current user/org info
-   */
-  async getMe() {
-    return this.fetch("/me");
-  }
-};
+  return runDeviceAuth(options?.baseUrl);
+}
 
-// src/claude-runner.ts
+// src/executor.ts
 var import_child_process = require("child_process");
-var import_events = require("events");
-var ClaudeRunner = class extends import_events.EventEmitter {
+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;
-  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
+      ...config,
+      timeout: config.timeout || DEFAULT_TIMEOUT,
+      claudePath: config.claudePath || "claude"
     };
   }
   /**
-   * Check if Claude Code is installed and authenticated
+   * Execute a task using Claude Code CLI
    */
-  async checkInstalled() {
+  async execute(task) {
     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 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 {
-        installed: false,
-        authenticated: false,
-        error: error instanceof Error ? error.message : "Unknown error"
+        success: false,
+        output: "",
+        summary: `Failed: ${errorMessage}`,
+        error: errorMessage
       };
     }
   }
   /**
-   * Run a task with Claude Code
+   * Run Claude Code CLI with the given prompt
    */
-  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 = (0, import_child_process.spawn)(this.config.claudePath, args, {
-        cwd,
+  runClaude(prompt) {
+    return new Promise((resolve, reject) => {
+      const claudePath = this.config.claudePath || "claude";
+      const proc = (0, import_child_process.spawn)(claudePath, ["--print"], {
         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()
-        });
+        timeout: this.config.timeout
       });
-      this.runningTasks.set(taskId, {
-        taskId,
-        process: proc,
-        startedAt,
-        promise
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
       });
-    });
-    return promise;
-  }
-  /**
-   * Run a raw claude command
-   */
-  runCommand(args) {
-    return new Promise((resolve) => {
-      const startedAt = Date.now();
-      let output = "";
-      let error = "";
-      const proc = (0, import_child_process.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.stderr.on("data", (data) => {
+        stderr += data.toString();
       });
       proc.on("close", (code) => {
-        resolve({
-          success: code === 0,
-          output: output.trim(),
-          error: error.trim() || void 0,
-          exitCode: code,
-          durationMs: Date.now() - startedAt
-        });
+        if (code === 0) {
+          resolve(stdout.trim());
+        } else {
+          reject(new Error(stderr || `Claude exited with code ${code}`));
+        }
       });
       proc.on("error", (err) => {
-        resolve({
-          success: false,
-          output: "",
-          error: err.message,
-          exitCode: null,
-          durationMs: Date.now() - startedAt
-        });
+        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();
     });
   }
   /**
-   * 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
+   * Build the task prompt
    */
-  getRunningCount() {
-    return this.runningTasks.size;
-  }
-  /**
-   * Cancel all running tasks
-   */
-  cancelAll() {
-    for (const [taskId] of this.runningTasks) {
-      this.cancelTask(taskId);
-    }
-  }
-};
+  buildTaskPrompt(task) {
+    const parts = [];
+    const systemPrompt = this.config.systemPromptPrefix ? `${this.config.systemPromptPrefix}
 
-// src/adapter.ts
-var ClaudeAdapter = class extends import_events2.EventEmitter {
-  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"
-      };
+${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 (!check.authenticated) {
-      return {
-        ready: false,
-        error: "Claude Code is not authenticated. Run: claude login"
-      };
+    if (task.priority) {
+      const priorityLabels = ["High", "Medium", "Low"];
+      parts.push(`**Priority:** ${priorityLabels[task.priority - 1] || "Medium"}`);
     }
-    return { ready: true };
-  }
-  /**
-   * Start the adapter
-   */
-  async start() {
-    if (this.running) return;
-    const { ready, error } = await this.checkReady();
-    if (!ready) {
-      throw new Error(error);
+    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("");
     }
-    this.running = true;
-    this.emit("started");
-    await this.poll();
-    this.pollTimer = setInterval(() => {
-      this.poll().catch((err) => this.emit("error", err));
-    }, this.config.pollIntervalMs);
+    parts.push("## Instructions");
+    parts.push("Complete this task and provide your output below.");
+    return parts.join("\n");
   }
   /**
-   * Stop the adapter
+   * Parse the response to extract output and summary
    */
-  async stop() {
-    if (!this.running) return;
-    this.running = false;
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
+  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 };
     }
-    this.runner.cancelAll();
-    this.emit("stopped");
+    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 };
   }
   /**
-   * Poll for and execute tasks
+   * Test that Claude Code CLI is available and working
    */
-  async poll() {
+  async testConnection() {
     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)));
+      const output = await this.runClaude('Say "connected" and nothing else.');
+      return output.toLowerCase().includes("connected");
+    } catch {
+      return false;
     }
   }
   /**
-   * Execute a single task
+   * Check if Claude Code CLI is installed
    */
-  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
+  async isInstalled() {
+    return new Promise((resolve) => {
+      const proc = (0, import_child_process.spawn)(this.config.claudePath || "claude", ["--version"], {
+        stdio: ["ignore", "pipe", "pipe"]
       });
-      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);
-    }
+      proc.on("close", (code) => {
+        resolve(code === 0);
+      });
+      proc.on("error", () => {
+        resolve(false);
+      });
+    });
   }
-  /**
-   * 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.
+};
+function createExecutor(config) {
+  return new ClaudeExecutor(config);
+}
 
-If you cannot complete the task, explain why clearly.`;
+// src/listener.ts
+var import_eventsource = __toESM(require("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
+    };
   }
   /**
-   * Extract a summary from Claude's output
+   * Get current connection state
    */
-  extractSummary(output) {
-    const maxLen = 500;
-    if (output.length <= maxLen) return output;
-    return "..." + output.slice(-maxLen);
+  get connectionState() {
+    return this.state;
   }
   /**
-   * Check if running
+   * Check if connected
    */
-  isRunning() {
-    return this.running;
+  get isConnected() {
+    return this.state === "connected";
   }
   /**
-   * Get stats
+   * Subscribe to all events
    */
-  getStats() {
-    return {
-      running: this.running,
-      activeTasks: this.activeTasks.size,
-      maxConcurrent: this.config.maxConcurrent
+  subscribe(callback) {
+    this.allCallbacks.add(callback);
+    return () => {
+      this.allCallbacks.delete(callback);
     };
   }
-};
-
-// src/auth.ts
-var import_child_process2 = require("child_process");
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os = __toESM(require("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
+   * Subscribe to a specific event type
    */
-  hasCredentials() {
-    return fs.existsSync(this.credentialsPath);
+  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);
+        }
+      }
+    };
   }
   /**
-   * Get stored credentials
+   * Connect to the SSE stream
    */
-  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;
+  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 import_eventsource.default(url.toString(), {
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`
       }
-      return creds;
-    } catch {
-      return null;
+    });
+    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);
+      });
     }
   }
   /**
-   * Get access token (for API calls)
+   * Disconnect from the SSE stream
    */
-  getAccessToken() {
-    const creds = this.getCredentials();
-    return creds?.accessToken ?? null;
-  }
-  /**
-   * Clear stored credentials (logout)
-   */
-  logout() {
-    if (fs.existsSync(this.credentialsPath)) {
-      fs.unlinkSync(this.credentialsPath);
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
     }
+    this.setState("disconnected");
   }
   /**
-   * Start device authorization flow
+   * Reconnect to the SSE stream
    */
-  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();
+  reconnect() {
+    this.disconnect();
+    this.connect();
   }
   /**
-   * Poll for token after user authorizes
+   * Handle incoming SSE message
    */
-  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.");
+  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);
+        }
       }
-      if (data.error === "access_denied") {
-        throw new Error("Authorization denied by user.");
+      for (const callback of this.allCallbacks) {
+        this.safeCallCallback(callback, artyfactsEvent);
       }
-      throw new Error(data.error ?? "Unknown error during authorization");
+    } catch (err) {
+      console.error("[Listener] Failed to parse SSE message:", event.data, err);
     }
-    throw new Error("Authorization timed out. Please try again.");
   }
   /**
-   * Save credentials to disk
+   * Safely call a callback, handling async and errors
    */
-  saveCredentials(token) {
-    const dir = path.dirname(this.credentialsPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+  async safeCallCallback(callback, event) {
+    try {
+      await callback(event);
+    } catch (err) {
+      console.error(`[Listener] Error in event callback for '${event.type}':`, err);
     }
-    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
+   * Handle SSE error
    */
-  openBrowser(url) {
-    const platform = process.platform;
-    try {
-      if (platform === "darwin") {
-        (0, import_child_process2.execSync)(`open "${url}"`);
-      } else if (platform === "win32") {
-        (0, import_child_process2.execSync)(`start "" "${url}"`);
+  handleError(event) {
+    if (this.eventSource?.readyState === import_eventsource.default.CONNECTING) {
+      this.setState("reconnecting");
+    } else if (this.eventSource?.readyState === import_eventsource.default.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 {
-        (0, import_child_process2.execSync)(`xdg-open "${url}"`);
+        const error = new Error("Max reconnection attempts reached");
+        this.config.onError?.(error);
       }
-    } catch {
-      console.log(`Please open this URL in your browser: ${url}`);
     }
   }
   /**
-   * Full login flow
+   * Update connection state
    */
-  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));
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.config.onStateChange?.(state);
+    }
   }
 };
+function createListener(config) {
+  return new ArtyfactsListener(config);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ArtyfactsClient,
-  ClaudeAdapter,
-  ClaudeRunner,
-  DeviceAuth
+  ArtyfactsListener,
+  ClaudeExecutor,
+  clearCredentials,
+  createExecutor,
+  createListener,
+  getCredentials,
+  loadCredentials,
+  promptForApiKey,
+  runDeviceAuth,
+  saveCredentials
 });
-//# sourceMappingURL=index.js.map