@artyfacts/claude 1.0.0

package/dist/index.js

@@ -0,0 +1,626 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ArtyfactsClient: () => ArtyfactsClient,
+  ClaudeAdapter: () => ClaudeAdapter,
+  ClaudeRunner: () => ClaudeRunner,
+  DeviceAuth: () => DeviceAuth
+});
+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
+      }
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API error (${response.status}): ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * Get claimable tasks from the queue
+   */
+  async getTaskQueue(options) {
+    const params = new URLSearchParams();
+    if (options?.limit) params.set("limit", options.limit.toString());
+    const result = await this.fetch(`/tasks/queue?${params}`);
+    return result.tasks;
+  }
+  /**
+   * Claim a task
+   */
+  async claimTask(taskId) {
+    return this.fetch(`/tasks/${taskId}/claim`, {
+      method: "POST",
+      body: JSON.stringify({ agent_id: this.config.agentId })
+    });
+  }
+  /**
+   * Complete a task
+   */
+  async completeTask(taskId, options) {
+    return this.fetch(`/tasks/${taskId}/complete`, {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.config.agentId,
+        output_url: options?.outputUrl,
+        summary: options?.summary
+      })
+    });
+  }
+  /**
+   * Report task as blocked
+   */
+  async blockTask(taskId, reason) {
+    await this.fetch(`/tasks/${taskId}/block`, {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.config.agentId,
+        reason
+      })
+    });
+  }
+  /**
+   * Get current user/org info
+   */
+  async getMe() {
+    return this.fetch("/me");
+  }
+};
+
+// src/claude-runner.ts
+var import_child_process = require("child_process");
+var import_events = require("events");
+var ClaudeRunner = class extends import_events.EventEmitter {
+  config;
+  runningTasks = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    super();
+    this.config = {
+      claudePath: config.claudePath ?? "claude",
+      model: config.model ?? "sonnet",
+      cwd: config.cwd ?? process.cwd(),
+      timeoutMs: config.timeoutMs ?? 5 * 60 * 1e3
+      // 5 minutes
+    };
+  }
+  /**
+   * Check if Claude Code is installed and authenticated
+   */
+  async checkInstalled() {
+    try {
+      const result = await this.runCommand(["--version"]);
+      const version = result.output.trim();
+      const authCheck = await this.runCommand(["-p", 'Say "ok"', "--print", "--max-turns", "1"]);
+      const authenticated = authCheck.success && !authCheck.output.includes("not authenticated");
+      return { installed: true, authenticated, version };
+    } catch (error) {
+      return {
+        installed: false,
+        authenticated: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Run a task with Claude Code
+   */
+  async runTask(taskId, prompt, options) {
+    const startedAt = /* @__PURE__ */ new Date();
+    const model = options?.model ?? this.config.model;
+    const cwd = options?.cwd ?? this.config.cwd;
+    const timeoutMs = options?.timeoutMs ?? this.config.timeoutMs;
+    const args = [
+      "-p",
+      prompt,
+      "--print",
+      "--output-format",
+      "text",
+      "--model",
+      model
+    ];
+    this.emit("task:start", { taskId, prompt, model });
+    const promise = new Promise((resolve) => {
+      let output = "";
+      let error = "";
+      const proc = (0, import_child_process.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 = (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.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 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"
+      };
+    }
+    if (!check.authenticated) {
+      return {
+        ready: false,
+        error: "Claude Code is not authenticated. Run: claude login"
+      };
+    }
+    return { ready: true };
+  }
+  /**
+   * Start the adapter
+   */
+  async start() {
+    if (this.running) return;
+    const { ready, error } = await this.checkReady();
+    if (!ready) {
+      throw new Error(error);
+    }
+    this.running = true;
+    this.emit("started");
+    await this.poll();
+    this.pollTimer = setInterval(() => {
+      this.poll().catch((err) => this.emit("error", err));
+    }, this.config.pollIntervalMs);
+  }
+  /**
+   * Stop the adapter
+   */
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.runner.cancelAll();
+    this.emit("stopped");
+  }
+  /**
+   * Poll for and execute tasks
+   */
+  async poll() {
+    try {
+      const available = this.config.maxConcurrent - this.activeTasks.size;
+      if (available <= 0) return;
+      const tasks = await this.client.getTaskQueue({ limit: available });
+      this.emit("poll", tasks);
+      for (const task of tasks) {
+        if (this.activeTasks.has(task.id)) continue;
+        if (this.activeTasks.size >= this.config.maxConcurrent) break;
+        await this.executeTask(task);
+      }
+    } catch (error) {
+      this.emit("error", error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Execute a single task
+   */
+  async executeTask(task) {
+    try {
+      const claim = await this.client.claimTask(task.id);
+      if (!claim.success) return;
+      this.activeTasks.add(task.id);
+      this.emit("task:claimed", task);
+      const prompt = this.buildPrompt(task);
+      this.emit("task:running", task);
+      const result = await this.runner.runTask(task.id, prompt, {
+        cwd: this.config.cwd
+      });
+      this.activeTasks.delete(task.id);
+      if (result.success) {
+        await this.client.completeTask(task.id, {
+          summary: this.extractSummary(result.output)
+        });
+        this.emit("task:completed", task, result);
+      } else {
+        await this.client.blockTask(task.id, result.error ?? "Task failed");
+        this.emit("task:failed", task, result.error ?? "Unknown error");
+      }
+    } catch (error) {
+      this.activeTasks.delete(task.id);
+      const message = error instanceof Error ? error.message : String(error);
+      this.emit("task:failed", task, message);
+    }
+  }
+  /**
+   * Build a prompt for Claude from the task
+   */
+  buildPrompt(task) {
+    return `You are working on a task from Artyfacts.
+
+## Task: ${task.heading}
+
+## Context
+- Artifact: ${task.artifactTitle}
+- URL: ${task.artifactUrl}
+- Priority: ${task.priority === 1 ? "High" : task.priority === 2 ? "Medium" : "Low"}
+
+## Details
+${task.content}
+
+## Instructions
+Complete this task to the best of your ability. When finished, provide a brief summary of what you accomplished.
+
+If you cannot complete the task, explain why clearly.`;
+  }
+  /**
+   * Extract a summary from Claude's output
+   */
+  extractSummary(output) {
+    const maxLen = 500;
+    if (output.length <= maxLen) return output;
+    return "..." + output.slice(-maxLen);
+  }
+  /**
+   * Check if running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get stats
+   */
+  getStats() {
+    return {
+      running: this.running,
+      activeTasks: this.activeTasks.size,
+      maxConcurrent: this.config.maxConcurrent
+    };
+  }
+};
+
+// src/auth.ts
+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
+   */
+  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") {
+        (0, import_child_process2.execSync)(`open "${url}"`);
+      } else if (platform === "win32") {
+        (0, import_child_process2.execSync)(`start "" "${url}"`);
+      } else {
+        (0, import_child_process2.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));
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArtyfactsClient,
+  ClaudeAdapter,
+  ClaudeRunner,
+  DeviceAuth
+});
+//# sourceMappingURL=index.js.map