@artyfacts/openclaw 0.1.0

package/dist/cli.js

@@ -0,0 +1,1508 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli.ts
+var import_commander = require("commander");
+
+// 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, "openclaw-credentials.json");
+var DEFAULT_BASE_URL = "https://artyfacts.dev/api/v1";
+var CLIENT_ID = "artyfacts-openclaw";
+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: CLIENT_ID,
+      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: CLIENT_ID
+      })
+    });
+    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
+var import_child_process = require("child_process");
+
+// src/context.ts
+var ContextFetcher = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Fetch full context for a task
+   */
+  async fetchTaskContext(taskId) {
+    const response = await fetch(
+      `${this.config.baseUrl}/tasks/${taskId}/context`,
+      {
+        headers: {
+          "Authorization": `Bearer ${this.config.apiKey}`,
+          "Accept": "application/json"
+        }
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      throw new Error(`Failed to fetch task context: ${response.status} - ${errorText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+};
+function buildPromptWithContext(context) {
+  const parts = [];
+  parts.push(`You are an AI agent working within the Artyfacts task management system.
+
+Your job is to complete the assigned task. You have full context about the organization, project, and related work.
+
+## Available Tools
+
+You have access to Artyfacts MCP tools. USE THEM to complete your task:
+
+- **create_artifact** - Create new artifacts (documents, specs, reports)
+- **create_section** - Add sections to artifacts (content, tasks, decisions)
+- **update_section** - Update existing sections
+- **create_agent** - Create new AI agents with specific roles
+- **list_artifacts** - Query existing artifacts
+- **list_sections** - Query sections within an artifact
+- **complete_task** - Mark a task as complete
+- **block_task** - Block a task with a reason
+- **create_blocker** - Create a decision blocker
+
+IMPORTANT: When asked to create agents or update artifacts, USE THE TOOLS. Don't just describe what you would do - actually do it with the tools.
+
+## Guidelines
+
+- Be thorough but concise
+- USE THE TOOLS to take action, don't just analyze
+- If the task requires creating something, use create_artifact or create_section
+- If the task requires creating agents, use create_agent
+- If you cannot complete the task, explain why
+
+Format your response as follows:
+1. First, use the tools to complete the task
+2. Then summarize what you did
+3. End with a brief summary line starting with "SUMMARY:"`);
+  parts.push("");
+  parts.push("---");
+  parts.push("");
+  parts.push("## Organization Context");
+  parts.push(`**${context.organization.name}**`);
+  if (context.organization.context) {
+    parts.push("");
+    parts.push(formatOrgContext(context.organization.context));
+  }
+  parts.push("");
+  if (context.project) {
+    parts.push(`## Project: ${context.project.name}`);
+    if (context.project.description) {
+      parts.push(context.project.description);
+    }
+    parts.push("");
+  }
+  parts.push(`## Artifact: ${context.artifact.title}`);
+  if (context.artifact.summary) {
+    parts.push(context.artifact.summary);
+  }
+  if (context.artifact.description) {
+    parts.push("");
+    parts.push(context.artifact.description);
+  }
+  parts.push("");
+  const relatedSections = context.artifact.sections.filter(
+    (s) => s.id !== context.task.id
+  );
+  if (relatedSections.length > 0) {
+    parts.push("### Related Sections:");
+    for (const section of relatedSections) {
+      const preview = section.content ? section.content.substring(0, 200) + (section.content.length > 200 ? "..." : "") : "No content";
+      const statusBadge = section.task_status ? ` [${section.task_status}]` : "";
+      parts.push(`- **${section.heading}**${statusBadge}: ${preview}`);
+    }
+    parts.push("");
+  }
+  parts.push("---");
+  parts.push("");
+  parts.push(`## Your Task: ${context.task.heading}`);
+  if (context.task.priority) {
+    const priorityLabels = ["\u{1F534} High", "\u{1F7E1} Medium", "\u{1F7E2} Low"];
+    parts.push(`**Priority:** ${priorityLabels[context.task.priority - 1] || "Medium"}`);
+  }
+  parts.push("");
+  parts.push("### Description");
+  parts.push(context.task.content || "No additional description provided.");
+  parts.push("");
+  if (context.task.expected_output) {
+    parts.push("### Expected Output");
+    if (context.task.expected_output.format) {
+      parts.push(`**Format:** ${context.task.expected_output.format}`);
+    }
+    if (context.task.expected_output.requirements && context.task.expected_output.requirements.length > 0) {
+      parts.push("**Requirements:**");
+      for (const req of context.task.expected_output.requirements) {
+        parts.push(`- ${req}`);
+      }
+    }
+    parts.push("");
+  }
+  parts.push("---");
+  parts.push("");
+  parts.push("Complete this task and provide your output below.");
+  return parts.join("\n");
+}
+function formatOrgContext(context) {
+  const trimmed = context.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return formatContextObject(parsed);
+    } catch {
+      return context;
+    }
+  }
+  return context;
+}
+function formatContextObject(obj, indent = "") {
+  if (typeof obj !== "object" || obj === null) {
+    return String(obj);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => `${indent}- ${formatContextObject(item, indent + "  ")}`).join("\n");
+  }
+  const lines = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const label = key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+    if (typeof value === "object" && value !== null) {
+      lines.push(`${indent}**${label}:**`);
+      lines.push(formatContextObject(value, indent + "  "));
+    } else {
+      lines.push(`${indent}- **${label}:** ${value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function createContextFetcher(config) {
+  return new ContextFetcher(config);
+}
+
+// src/executor.ts
+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 using the available tools.
+
+## Available Tools
+
+You have access to Artyfacts MCP tools. USE THEM to complete your task:
+
+- **create_artifact** - Create new artifacts (documents, specs, reports)
+- **create_section** - Add sections to artifacts (content, tasks, decisions)
+- **update_section** - Update existing sections
+- **create_agent** - Create new AI agents with specific roles
+- **list_artifacts** - Query existing artifacts
+- **list_sections** - Query sections within an artifact
+- **complete_task** - Mark a task as complete
+- **block_task** - Block a task with a reason
+- **create_blocker** - Create a decision blocker
+
+IMPORTANT: When asked to create agents or update artifacts, USE THE TOOLS. Don't just describe what you would do - actually do it.
+
+## Guidelines
+
+- USE THE TOOLS to take action
+- If creating something, use create_artifact or create_section
+- If creating agents, use create_agent
+- If you cannot complete the task, explain why
+
+Format your response as follows:
+1. First, use the tools to complete the task
+2. Summarize what you accomplished
+3. End with a brief summary line starting with "SUMMARY:"`;
+var OpenClawExecutor = class {
+  constructor(config = {}) {
+    this.contextFetcher = null;
+    this.config = {
+      ...config,
+      timeout: config.timeout || DEFAULT_TIMEOUT,
+      openclawPath: config.openclawPath || "openclaw"
+    };
+    if (config.baseUrl && config.apiKey) {
+      this.contextFetcher = createContextFetcher({
+        baseUrl: config.baseUrl,
+        apiKey: config.apiKey
+      });
+    }
+  }
+  /**
+   * Check if OpenClaw CLI is installed
+   */
+  async isInstalled() {
+    try {
+      const result = (0, import_child_process.spawnSync)(this.config.openclawPath || "openclaw", ["--version"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return result.status === 0;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get OpenClaw version
+   */
+  async getVersion() {
+    try {
+      const result = (0, import_child_process.spawnSync)(this.config.openclawPath || "openclaw", ["--version"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (result.status === 0) {
+        return result.stdout.trim();
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Execute a task using OpenClaw CLI
+   */
+  async execute(task) {
+    try {
+      let prompt;
+      let fullContext = null;
+      const useFullContext = this.config.useFullContext !== false && this.contextFetcher;
+      if (useFullContext) {
+        try {
+          fullContext = await this.contextFetcher.fetchTaskContext(task.taskId);
+          prompt = buildPromptWithContext(fullContext);
+          console.log("  \u{1F4DA} Using full context (org, project, artifact, related sections)");
+        } catch (contextError) {
+          console.warn("  \u26A0\uFE0F  Could not fetch full context, using minimal prompt");
+          console.warn(`     ${contextError instanceof Error ? contextError.message : contextError}`);
+          prompt = this.buildTaskPrompt(task);
+        }
+      } else {
+        prompt = this.buildTaskPrompt(task);
+      }
+      const output = await this.runOpenClaw(prompt);
+      const { content, summary } = this.parseResponse(output, task.heading);
+      return {
+        success: true,
+        output: content,
+        summary,
+        promptUsed: prompt
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        output: "",
+        summary: `Failed: ${errorMessage}`,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Run OpenClaw CLI with the given prompt
+   */
+  runOpenClaw(prompt) {
+    return new Promise((resolve, reject) => {
+      const openclawPath = this.config.openclawPath || "openclaw";
+      const args = [
+        "prompt",
+        "--output-format",
+        "text"
+        // Get plain text output
+      ];
+      if (this.config.sessionKey) {
+        args.push("--session", this.config.sessionKey);
+      }
+      args.push(prompt);
+      const proc = (0, import_child_process.spawn)(openclawPath, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: this.config.timeout,
+        env: {
+          ...process.env,
+          // Pass Artyfacts API key for MCP tools
+          ARTYFACTS_API_KEY: this.config.apiKey || process.env.ARTYFACTS_API_KEY || "",
+          ARTYFACTS_BASE_URL: this.config.baseUrl || "https://artyfacts.dev/api/v1"
+        }
+      });
+      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 || `OpenClaw exited with code ${code}`));
+        }
+      });
+      proc.on("error", (err) => {
+        if (err.code === "ENOENT") {
+          reject(new Error(
+            "OpenClaw CLI not found. Please install it:\n  npm install -g openclaw"
+          ));
+        } else {
+          reject(err);
+        }
+      });
+    });
+  }
+  /**
+   * 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(`**Part of:** ${task.artifactTitle}`);
+      parts.push(`**Artifact ID:** ${task.artifactId}`);
+      parts.push("");
+    }
+    if (task.priority) {
+      const priorityLabel = ["High", "Medium", "Low"][task.priority - 1] || "Unknown";
+      parts.push(`**Priority:** ${priorityLabel}`);
+      parts.push("");
+    }
+    parts.push("## Description");
+    parts.push("");
+    parts.push(task.content || "No description provided.");
+    parts.push("");
+    if (task.context && Object.keys(task.context).length > 0) {
+      parts.push("## Additional Context");
+      parts.push("");
+      parts.push("```json");
+      parts.push(JSON.stringify(task.context, null, 2));
+      parts.push("```");
+      parts.push("");
+    }
+    parts.push("---");
+    parts.push("");
+    parts.push("Please complete this task using the available Artyfacts tools.");
+    parts.push("When done, provide a summary of what you accomplished.");
+    return parts.join("\n");
+  }
+  /**
+   * Parse the response to extract content and summary
+   */
+  parseResponse(output, fallbackSummary) {
+    const summaryMatch = output.match(/SUMMARY:\s*(.+?)(?:\n|$)/i);
+    if (summaryMatch) {
+      const summary2 = summaryMatch[1].trim();
+      const content = output.replace(/SUMMARY:\s*.+?(?:\n|$)/i, "").trim();
+      return { content, summary: summary2 };
+    }
+    const lines = output.split("\n").filter((l) => l.trim());
+    const summary = lines.length > 0 ? lines[lines.length - 1].slice(0, 200) : `Completed: ${fallbackSummary}`;
+    return { content: output, summary };
+  }
+};
+function createExecutor(config) {
+  return new OpenClawExecutor(config);
+}
+
+// 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",
+  "mcp_connect_request",
+  "connection_status"
+];
+var ArtyfactsListener = class {
+  constructor(config) {
+    this.eventSource = null;
+    this.callbacks = /* @__PURE__ */ new Map();
+    this.allCallbacks = /* @__PURE__ */ new Set();
+    this.state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.reconnectDelay = 1e3;
+    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 import_eventsource.default(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 rawData = data.data || data;
+      const normalizedData = rawData.task_id ? {
+        taskId: rawData.task_id,
+        sectionId: rawData.section_id,
+        artifactId: rawData.artifact_id,
+        artifactTitle: rawData.artifact_title,
+        heading: rawData.heading,
+        content: rawData.content,
+        assignedTo: rawData.assigned_to,
+        assignedAt: rawData.assigned_at,
+        priority: rawData.priority,
+        ...rawData
+        // Keep original fields too
+      } : rawData;
+      const artyfactsEvent = {
+        type: eventType || data.type || "unknown",
+        timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+        data: normalizedData
+      };
+      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 === 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 {
+        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);
+}
+
+// src/mcp.ts
+var import_child_process2 = require("child_process");
+var DEFAULT_MCP_NAME = "artyfacts";
+var DEFAULT_BASE_URL3 = "https://artyfacts.dev/api/v1";
+var McpHandler = class {
+  constructor(config) {
+    this.config = {
+      name: DEFAULT_MCP_NAME,
+      baseUrl: DEFAULT_BASE_URL3,
+      ...config
+    };
+    this.openclawPath = config.openclawPath || "openclaw";
+  }
+  /**
+   * Check if Artyfacts MCP server is already configured
+   */
+  isConfigured() {
+    try {
+      const result = (0, import_child_process2.spawnSync)(this.openclawPath, ["mcp", "show", this.config.name || DEFAULT_MCP_NAME], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (result.status === 0) {
+        return {
+          configured: true,
+          name: this.config.name
+        };
+      }
+      return { configured: false };
+    } catch (error) {
+      return {
+        configured: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Configure Artyfacts MCP server in OpenClaw
+   * 
+   * Uses: openclaw mcp set <name> --command "npx" --args "-y @artyfacts/mcp-server"
+   */
+  configure() {
+    console.log("\u{1F527} Configuring Artyfacts tools for OpenClaw...");
+    try {
+      const result = (0, import_child_process2.spawnSync)(this.openclawPath, [
+        "mcp",
+        "set",
+        this.config.name || DEFAULT_MCP_NAME,
+        "--command",
+        "npx",
+        "--args",
+        "-y",
+        "--args",
+        "@artyfacts/mcp-server",
+        "--env",
+        `ARTYFACTS_API_KEY=${this.config.apiKey}`,
+        "--env",
+        `ARTYFACTS_BASE_URL=${this.config.baseUrl || DEFAULT_BASE_URL3}`
+      ], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (result.status === 0) {
+        console.log("\u2705 MCP tools configured! OpenClaw now has access to Artyfacts.");
+        return true;
+      } else {
+        return this.configureAlternative();
+      }
+    } catch (error) {
+      console.log("\u26A0\uFE0F  Could not configure MCP:", error instanceof Error ? error.message : error);
+      this.printManualInstructions();
+      return false;
+    }
+  }
+  /**
+   * Alternative configuration approach using JSON config
+   */
+  configureAlternative() {
+    try {
+      const mcpConfig = JSON.stringify({
+        command: "npx",
+        args: ["-y", "@artyfacts/mcp-server"],
+        env: {
+          ARTYFACTS_API_KEY: this.config.apiKey,
+          ARTYFACTS_BASE_URL: this.config.baseUrl || DEFAULT_BASE_URL3
+        }
+      });
+      const result = (0, import_child_process2.spawnSync)(this.openclawPath, [
+        "mcp",
+        "set",
+        this.config.name || DEFAULT_MCP_NAME,
+        "--config",
+        mcpConfig
+      ], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (result.status === 0) {
+        console.log("\u2705 MCP tools configured! OpenClaw now has access to Artyfacts.");
+        return true;
+      } else {
+        console.log("\u26A0\uFE0F  Could not configure MCP:", result.stderr || result.stdout);
+        this.printManualInstructions();
+        return false;
+      }
+    } catch (error) {
+      console.log("\u26A0\uFE0F  Could not configure MCP:", error instanceof Error ? error.message : error);
+      this.printManualInstructions();
+      return false;
+    }
+  }
+  /**
+   * Print manual configuration instructions
+   */
+  printManualInstructions() {
+    console.log("");
+    console.log("You can manually add the Artyfacts MCP server with:");
+    console.log("");
+    console.log(`  openclaw mcp set ${this.config.name || DEFAULT_MCP_NAME} \\`);
+    console.log(`    --command "npx" \\`);
+    console.log(`    --args "-y" --args "@artyfacts/mcp-server" \\`);
+    console.log(`    --env "ARTYFACTS_API_KEY=${this.config.apiKey}" \\`);
+    console.log(`    --env "ARTYFACTS_BASE_URL=${this.config.baseUrl || DEFAULT_BASE_URL3}"`);
+    console.log("");
+    console.log("Or add to your openclaw.json:");
+    console.log("");
+    console.log(`  "mcp": {`);
+    console.log(`    "${this.config.name || DEFAULT_MCP_NAME}": {`);
+    console.log(`      "command": "npx",`);
+    console.log(`      "args": ["-y", "@artyfacts/mcp-server"],`);
+    console.log(`      "env": {`);
+    console.log(`        "ARTYFACTS_API_KEY": "<your-api-key>",`);
+    console.log(`        "ARTYFACTS_BASE_URL": "${this.config.baseUrl || DEFAULT_BASE_URL3}"`);
+    console.log(`      }`);
+    console.log(`    }`);
+    console.log(`  }`);
+    console.log("");
+  }
+  /**
+   * Remove Artyfacts MCP configuration
+   */
+  remove() {
+    try {
+      const result = (0, import_child_process2.spawnSync)(this.openclawPath, [
+        "mcp",
+        "unset",
+        this.config.name || DEFAULT_MCP_NAME
+      ], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      if (result.status === 0) {
+        console.log("\u2705 Artyfacts MCP configuration removed.");
+        return true;
+      } else {
+        console.log("\u26A0\uFE0F  Could not remove MCP config:", result.stderr || result.stdout);
+        return false;
+      }
+    } catch (error) {
+      console.log("\u26A0\uFE0F  Could not remove MCP config:", error instanceof Error ? error.message : error);
+      return false;
+    }
+  }
+  /**
+   * Ensure MCP is configured, configure if needed
+   */
+  ensureConfigured() {
+    const status = this.isConfigured();
+    if (status.configured) {
+      console.log("\u2705 Artyfacts MCP tools already configured");
+      return true;
+    }
+    return this.configure();
+  }
+};
+function createMcpHandler(config) {
+  return new McpHandler(config);
+}
+
+// src/introspect.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var import_os = require("os");
+var import_child_process3 = require("child_process");
+var OPENCLAW_DIR = (0, import_path.join)((0, import_os.homedir)(), ".openclaw");
+var CONFIG_FILE = (0, import_path.join)(OPENCLAW_DIR, "openclaw.json");
+var CRON_FILE = (0, import_path.join)(OPENCLAW_DIR, "cron", "jobs.json");
+var SKILLS_DIR = (0, import_path.join)(OPENCLAW_DIR, "skills");
+function parseJson5(content) {
+  const stripped = content.split("\n").map((line) => {
+    const commentIndex = line.indexOf("//");
+    if (commentIndex === -1) return line;
+    const beforeComment = line.slice(0, commentIndex);
+    const quotes = (beforeComment.match(/"/g) || []).length;
+    if (quotes % 2 === 0) {
+      return beforeComment;
+    }
+    return line;
+  }).join("\n");
+  const noTrailing = stripped.replace(/,(\s*[}\]])/g, "$1");
+  return JSON.parse(noTrailing);
+}
+async function readCronJobs() {
+  try {
+    const content = await (0, import_promises.readFile)(CRON_FILE, "utf-8");
+    const jobs = JSON.parse(content);
+    return Array.isArray(jobs) ? jobs : [];
+  } catch (err) {
+    return [];
+  }
+}
+async function readMainConfig() {
+  try {
+    const content = await (0, import_promises.readFile)(CONFIG_FILE, "utf-8");
+    const config = parseJson5(content);
+    const agentsConfig = config.agents;
+    const defaults = agentsConfig?.defaults;
+    const heartbeat = defaults?.heartbeat;
+    const agentsList = agentsConfig?.list || [];
+    const channelsConfig = config.channels;
+    const channelNames = channelsConfig ? Object.keys(channelsConfig).filter((k) => k !== "defaults") : [];
+    return {
+      heartbeat: heartbeat || null,
+      agents: agentsList,
+      channels: channelNames
+    };
+  } catch (err) {
+    return { heartbeat: null, agents: [], channels: [] };
+  }
+}
+async function readMcpServers() {
+  try {
+    const output = (0, import_child_process3.execSync)("openclaw mcp list --json 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const servers = JSON.parse(output);
+    return Array.isArray(servers) ? servers : [];
+  } catch (err) {
+    return [];
+  }
+}
+async function readSkills() {
+  const skills = [];
+  async function scanDir(dir, prefix = "") {
+    try {
+      const entries = await (0, import_promises.readdir)(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = (0, import_path.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+          await scanDir(fullPath, prefix ? `${prefix}/${entry.name}` : entry.name);
+        } else if (entry.name === "SKILL.md") {
+          const skillName = prefix || "root";
+          const content = await (0, import_promises.readFile)(fullPath, "utf-8");
+          const lines = content.split("\n");
+          const descLine = lines.find((l) => l.trim() && !l.startsWith("#"));
+          skills.push({
+            name: skillName,
+            path: fullPath,
+            description: descLine?.trim().slice(0, 200),
+            content
+          });
+        }
+      }
+    } catch (err) {
+    }
+  }
+  await scanDir(SKILLS_DIR);
+  return skills;
+}
+async function introspect() {
+  const [crons, mainConfig, mcpServers, skills] = await Promise.all([
+    readCronJobs(),
+    readMainConfig(),
+    readMcpServers(),
+    readSkills()
+  ]);
+  return {
+    crons,
+    heartbeat: mainConfig.heartbeat,
+    agents: mainConfig.agents,
+    mcpServers,
+    skills,
+    channels: mainConfig.channels
+  };
+}
+function summarize(config) {
+  const parts = [];
+  if (config.crons.length > 0) {
+    parts.push(`${config.crons.length} cron job(s)`);
+  }
+  if (config.heartbeat) {
+    parts.push(`heartbeat: ${config.heartbeat.every || "30m"}`);
+  }
+  if (config.agents.length > 0) {
+    parts.push(`${config.agents.length} agent(s)`);
+  }
+  if (config.mcpServers.length > 0) {
+    parts.push(`${config.mcpServers.length} MCP server(s)`);
+  }
+  if (config.skills.length > 0) {
+    parts.push(`${config.skills.length} skill(s)`);
+  }
+  if (config.channels.length > 0) {
+    parts.push(`channels: ${config.channels.join(", ")}`);
+  }
+  return parts.length > 0 ? parts.join(" | ") : "No configuration found";
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+var DEFAULT_BASE_URL4 = "https://artyfacts.dev/api/v1";
+function isMcpConfigured(openclawPath = "openclaw") {
+  const handler = createMcpHandler({ apiKey: "", openclawPath });
+  return handler.isConfigured().configured;
+}
+function configureMcp(apiKey, baseUrl, openclawPath = "openclaw") {
+  const handler = createMcpHandler({ apiKey, baseUrl, openclawPath });
+  return handler.configure();
+}
+function ensureMcpConfigured(apiKey, baseUrl, openclawPath = "openclaw") {
+  if (isMcpConfigured(openclawPath)) {
+    console.log("\u2705 Artyfacts MCP tools already configured");
+    return;
+  }
+  configureMcp(apiKey, baseUrl, openclawPath);
+}
+var program = new import_commander.Command();
+program.name("artyfacts-openclaw").description("OpenClaw adapter for Artyfacts - Execute tasks using OpenClaw CLI").version(VERSION);
+program.command("run", { isDefault: true }).description("Start listening for and executing tasks").option("--base-url <url>", "Artyfacts API base URL", DEFAULT_BASE_URL4).option("--dry-run", "Print tasks but do not execute", false).option("--openclaw-path <path>", "Path to openclaw CLI", "openclaw").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_URL4).action(async (options) => {
+  try {
+    if (options.manual) {
+      await promptForApiKey();
+    } else {
+      await getCredentials({ baseUrl: options.baseUrl, forceAuth: true });
+    }
+  } catch (error) {
+    console.error("\u274C Authentication failed:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Clear stored credentials").action(() => {
+  clearCredentials();
+  console.log("\u2705 Credentials cleared");
+});
+program.command("status").description("Check authentication and connection status").option("--openclaw-path <path>", "Path to openclaw CLI", "openclaw").action(async (options) => {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log("\u274C Not authenticated");
+    console.log("   Run: npx @artyfacts/openclaw login");
+    process.exit(1);
+  }
+  console.log("\u2705 Authenticated");
+  console.log(`   Agent ID: ${credentials.agentId}`);
+  if (credentials.agentName) {
+    console.log(`   Agent Name: ${credentials.agentName}`);
+  }
+  const executor = createExecutor({ openclawPath: options.openclawPath });
+  const installed = await executor.isInstalled();
+  if (installed) {
+    const version = await executor.getVersion();
+    console.log(`\u2705 OpenClaw CLI installed${version ? ` (${version})` : ""}`);
+  } else {
+    console.log("\u274C OpenClaw CLI not found");
+    console.log("   Install with: npm install -g openclaw");
+  }
+  if (isMcpConfigured(options.openclawPath)) {
+    console.log("\u2705 Artyfacts MCP tools configured");
+  } else {
+    console.log("\u26A0\uFE0F  Artyfacts MCP tools not configured");
+    console.log("   Will configure automatically on first run");
+  }
+  console.log("");
+  console.log("\u{1F4C2} Local Configuration:");
+  try {
+    const config = await introspect();
+    const summary = summarize(config);
+    console.log(`   ${summary}`);
+    if (config.crons.length > 0 || config.skills.length > 0 || config.mcpServers.length > 0) {
+      console.log("");
+      console.log("   Run `npx @artyfacts/openclaw introspect` for details");
+      console.log("   Run `npx @artyfacts/openclaw import` to sync to Artyfacts");
+    }
+  } catch (err) {
+    console.log("   (Could not read local config)");
+  }
+});
+program.command("introspect").description("Show detailed local OpenClaw configuration").option("--json", "Output as JSON").action(async (options) => {
+  try {
+    const config = await introspect();
+    if (options.json) {
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+    console.log("");
+    console.log("\u{1F4C2} OpenClaw Configuration");
+    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");
+    console.log("");
+    console.log(`\u{1F4C5} Cron Jobs (${config.crons.length})`);
+    if (config.crons.length === 0) {
+      console.log("   (none)");
+    } else {
+      for (const job of config.crons) {
+        const schedule = job.schedule.cron || job.schedule.every || job.schedule.at;
+        const status = job.enabled === false ? " [disabled]" : "";
+        console.log(`   \u2022 ${job.name || job.jobId}: ${schedule}${status}`);
+      }
+    }
+    console.log("");
+    console.log("\u{1F493} Heartbeat");
+    if (config.heartbeat) {
+      console.log(`   Interval: ${config.heartbeat.every || "30m"}`);
+      if (config.heartbeat.target) {
+        console.log(`   Target: ${config.heartbeat.target}${config.heartbeat.to ? ` \u2192 ${config.heartbeat.to}` : ""}`);
+      }
+      if (config.heartbeat.activeHours) {
+        console.log(`   Active: ${config.heartbeat.activeHours.start} - ${config.heartbeat.activeHours.end}`);
+      }
+    } else {
+      console.log("   (using defaults or disabled)");
+    }
+    console.log("");
+    console.log(`\u{1F916} Agents (${config.agents.length})`);
+    if (config.agents.length === 0) {
+      console.log("   (using default agent)");
+    } else {
+      for (const agent of config.agents) {
+        const def = agent.default ? " [default]" : "";
+        console.log(`   \u2022 ${agent.id}${agent.name ? ` (${agent.name})` : ""}${def}`);
+      }
+    }
+    console.log("");
+    console.log(`\u{1F50C} MCP Servers (${config.mcpServers.length})`);
+    if (config.mcpServers.length === 0) {
+      console.log("   (none)");
+    } else {
+      for (const server of config.mcpServers) {
+        console.log(`   \u2022 ${server.name}: ${server.url || server.command}`);
+      }
+    }
+    console.log("");
+    console.log(`\u{1F4DA} Skills (${config.skills.length})`);
+    if (config.skills.length === 0) {
+      console.log("   (none in ~/.openclaw/skills/)");
+    } else {
+      for (const skill of config.skills) {
+        const desc = skill.description ? ` - ${skill.description.slice(0, 50)}...` : "";
+        console.log(`   \u2022 ${skill.name}${desc}`);
+      }
+    }
+    console.log("");
+    console.log(`\u{1F4F1} Channels (${config.channels.length})`);
+    if (config.channels.length === 0) {
+      console.log("   (none configured)");
+    } else {
+      console.log(`   ${config.channels.join(", ")}`);
+    }
+    console.log("");
+  } catch (err) {
+    console.error("\u274C Failed to read configuration:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("import").description("Import local OpenClaw configuration to Artyfacts").option("--base-url <url>", "Artyfacts API base URL", DEFAULT_BASE_URL4).option("--dry-run", "Show what would be imported without importing").option("--crons", "Import only cron jobs").option("--skills", "Import only skills").option("--mcp", "Import only MCP servers").option("--agents", "Import only agents").action(async (options) => {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log("\u274C Not authenticated. Run login first:");
+    console.log("   npx @artyfacts/openclaw login");
+    process.exit(1);
+  }
+  try {
+    const config = await introspect();
+    const importAll = !options.crons && !options.skills && !options.mcp && !options.agents;
+    const toImport = {
+      crons: importAll || options.crons,
+      skills: importAll || options.skills,
+      mcp: importAll || options.mcp,
+      agents: importAll || options.agents
+    };
+    console.log("");
+    console.log("\u{1F4E4} Importing to Artyfacts");
+    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");
+    console.log("");
+    const payload = {
+      source: "openclaw",
+      agentId: credentials.agentId
+    };
+    if (toImport.crons && config.crons.length > 0) {
+      console.log(`\u{1F4C5} Cron jobs: ${config.crons.length}`);
+      payload.crons = config.crons;
+    }
+    if (toImport.skills && config.skills.length > 0) {
+      console.log(`\u{1F4DA} Skills: ${config.skills.length}`);
+      payload.skills = config.skills.map((s) => ({
+        name: s.name,
+        description: s.description,
+        content: s.content
+      }));
+    }
+    if (toImport.mcp && config.mcpServers.length > 0) {
+      console.log(`\u{1F50C} MCP servers: ${config.mcpServers.length}`);
+      payload.mcpServers = config.mcpServers;
+    }
+    if (toImport.agents && config.agents.length > 0) {
+      console.log(`\u{1F916} Agents: ${config.agents.length}`);
+      payload.agents = config.agents;
+    }
+    if (config.heartbeat && (importAll || options.agents)) {
+      console.log("\u{1F493} Heartbeat config");
+      payload.heartbeat = config.heartbeat;
+    }
+    if (config.channels.length > 0 && importAll) {
+      payload.channels = config.channels;
+    }
+    console.log("");
+    if (options.dryRun) {
+      console.log("[DRY RUN] Would import:");
+      console.log(JSON.stringify(payload, null, 2));
+      return;
+    }
+    const response = await fetch(`${options.baseUrl}/agents/${credentials.agentId}/config/import`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${credentials.apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Import failed: ${errorText}`);
+    }
+    const result = await response.json();
+    console.log("\u2705 Import successful!");
+    if (result.imported) {
+      console.log(`   Imported: ${Object.entries(result.imported).map(([k, v]) => `${v} ${k}`).join(", ")}`);
+    }
+    console.log("");
+    console.log("   View in Artyfacts: https://artyfacts.dev/agents/" + credentials.agentId);
+    console.log("");
+  } catch (err) {
+    console.error("\u274C Import failed:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("configure").description("Configure Artyfacts MCP tools for OpenClaw").option("--base-url <url>", "Artyfacts API base URL", DEFAULT_BASE_URL4).option("--openclaw-path <path>", "Path to openclaw CLI", "openclaw").action(async (options) => {
+  const credentials = loadCredentials();
+  if (!credentials) {
+    console.log("\u274C Not authenticated. Run login first:");
+    console.log("   npx @artyfacts/openclaw login");
+    process.exit(1);
+  }
+  const success = configureMcp(credentials.apiKey, options.baseUrl, options.openclawPath);
+  if (!success) {
+    process.exit(1);
+  }
+});
+async function runAgent(options) {
+  console.log("");
+  console.log("\u{1F99E} Artyfacts OpenClaw Adapter");
+  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");
+  console.log("");
+  const credentials = await getCredentials({ baseUrl: options.baseUrl });
+  const executor = createExecutor({
+    openclawPath: options.openclawPath,
+    baseUrl: options.baseUrl,
+    apiKey: credentials.apiKey
+  });
+  const installed = await executor.isInstalled();
+  if (!installed) {
+    console.error("\u274C OpenClaw CLI not found. Please install it:");
+    console.error("   npm install -g openclaw");
+    process.exit(1);
+  }
+  ensureMcpConfigured(credentials.apiKey, options.baseUrl, options.openclawPath);
+  console.log("");
+  const listener = createListener({
+    baseUrl: options.baseUrl,
+    apiKey: credentials.apiKey,
+    agentId: credentials.agentId,
+    onStateChange: (state) => {
+      if (state === "disconnected") {
+        console.log("\u26A0\uFE0F  Disconnected from Artyfacts");
+      } else if (state === "reconnecting") {
+        console.log("\u{1F504} Reconnecting...");
+      }
+    },
+    onError: (error) => {
+      console.error("\u274C Listener error:", error.message);
+    }
+  });
+  listener.on("task_assigned", async (event) => {
+    const task = event.data;
+    console.log("");
+    console.log("\u{1F4CB} Task received:");
+    console.log(`   ${task.heading}`);
+    console.log(`   ID: ${task.sectionId}`);
+    console.log(`   Artifact: ${task.artifactTitle || task.artifactId}`);
+    console.log("");
+    if (options.dryRun) {
+      console.log("   [DRY RUN] Would execute task");
+      return;
+    }
+    console.log("\u{1F504} Executing task...");
+    const taskContext = {
+      taskId: task.sectionId,
+      heading: task.heading,
+      content: task.content,
+      artifactId: task.artifactId,
+      artifactTitle: task.artifactTitle,
+      priority: task.priority
+    };
+    const result = await executor.execute(taskContext);
+    if (result.success) {
+      console.log("\u2705 Task completed");
+      console.log(`   Summary: ${result.summary}`);
+      try {
+        await reportTaskCompletion(options.baseUrl, credentials.apiKey, {
+          taskId: task.sectionId,
+          success: true,
+          summary: result.summary,
+          output: result.output
+        });
+        console.log("   \u{1F4E4} Result reported to Artyfacts");
+      } catch (reportError) {
+        console.error("   \u26A0\uFE0F  Failed to report result:", reportError);
+      }
+    } else {
+      console.log("\u274C Task failed");
+      console.log(`   Error: ${result.error}`);
+      try {
+        await reportTaskCompletion(options.baseUrl, credentials.apiKey, {
+          taskId: task.sectionId,
+          success: false,
+          error: result.error
+        });
+      } catch (reportError) {
+        console.error("   \u26A0\uFE0F  Failed to report error:", reportError);
+      }
+    }
+  });
+  listener.on("mcp_connect_request", async (event) => {
+    console.log("");
+    console.log(`\u{1F50C} MCP connection request: ${event.data.platform}`);
+    console.log("   (MCP connection handling not yet implemented for OpenClaw)");
+  });
+  listener.on("connected", (event) => {
+    console.log("\u2705 Connected to Artyfacts");
+    console.log("\u{1F3A7} Listening for tasks...");
+    console.log("");
+  });
+  await listener.connect();
+  process.on("SIGINT", () => {
+    console.log("");
+    console.log("\u{1F44B} Shutting down...");
+    listener.disconnect();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    listener.disconnect();
+    process.exit(0);
+  });
+}
+async function reportTaskCompletion(baseUrl, apiKey, result) {
+  const endpoint = `${baseUrl}/tasks/${result.taskId}/complete`;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      status: result.success ? "done" : "failed",
+      output_summary: result.summary || result.error,
+      output_url: null
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to report completion: ${errorText}`);
+  }
+}
+program.parse();