deepline 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/cli/commands/auth.ts
+var import_node_fs2 = require("fs");
+var import_node_os2 = require("os");
+var import_node_os3 = require("os");
+var import_node_path2 = require("path");
+
+// src/config.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+
+// src/errors.ts
+var DeeplineError = class extends Error {
+  constructor(message, statusCode, code, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.details = details;
+    this.name = "DeeplineError";
+  }
+  statusCode;
+  code;
+  details;
+};
+var AuthError = class extends DeeplineError {
+  constructor(message = "Authentication failed. Check your DEEPLINE_API_KEY.") {
+    super(message, 401, "AUTH_ERROR");
+    this.name = "AuthError";
+  }
+};
+var RateLimitError = class extends DeeplineError {
+  retryAfterMs;
+  constructor(retryAfterMs = 5e3, message) {
+    super(message ?? `Rate limited. Retry after ${retryAfterMs}ms.`, 429, "RATE_LIMIT");
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var ConfigError = class extends DeeplineError {
+  constructor(message) {
+    super(message, void 0, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+};
+
+// src/config.ts
+var PROD_URL = "https://code.deepline.com";
+var DEFAULT_TIMEOUT = 6e4;
+var DEFAULT_MAX_RETRIES = 3;
+function baseUrlSlug(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    return "unknown";
+  }
+  const host = url.hostname || "unknown";
+  const port = url.port ? parseInt(url.port, 10) : null;
+  let slug = host.replace(/[^a-zA-Z0-9]/g, "-");
+  if (port && port !== 80 && port !== 443) {
+    slug = `${slug}-${port}`;
+  }
+  return slug.toLowerCase().replace(/^-+|-+$/g, "");
+}
+function parseEnvFile(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return {};
+  const env = {};
+  const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex < 0) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key && value) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function loadCliEnv(baseUrl) {
+  const slug = baseUrlSlug(baseUrl);
+  const envPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".local", "deepline", slug, ".env");
+  return parseEnvFile(envPath);
+}
+function autoDetectBaseUrl() {
+  const envBase = process.env.DEEPLINE_API_BASE_URL?.trim();
+  if (envBase) return envBase;
+  const localEnvPath = (0, import_node_path.join)((0, import_node_os.homedir)(), ".local", "deepline", "localhost-3000", ".env");
+  if ((0, import_node_fs.existsSync)(localEnvPath)) {
+    return "http://localhost:3000";
+  }
+  return PROD_URL;
+}
+function resolveConfig(options) {
+  const baseUrl = options?.baseUrl?.trim() || autoDetectBaseUrl();
+  const cliEnv = loadCliEnv(baseUrl);
+  const apiKey = options?.apiKey?.trim() || process.env.DEEPLINE_API_KEY?.trim() || cliEnv.DEEPLINE_API_KEY || "";
+  if (!apiKey) {
+    throw new ConfigError(
+      `No API key found. Set DEEPLINE_API_KEY env var, pass apiKey option, or run: deepline auth register`
+    );
+  }
+  return {
+    apiKey,
+    baseUrl: baseUrl.replace(/\/$/, ""),
+    timeout: options?.timeout ?? DEFAULT_TIMEOUT,
+    maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES
+  };
+}
+
+// src/cli/commands/auth.ts
+var EXIT_OK = 0;
+var EXIT_AUTH = 1;
+var EXIT_SERVER = 2;
+function envFilePath(baseUrl) {
+  const slug = baseUrlSlug(baseUrl);
+  return (0, import_node_path2.join)((0, import_node_os2.homedir)(), ".local", "deepline", slug, ".env");
+}
+function saveEnvValues(values, baseUrl) {
+  const filePath = envFilePath(baseUrl);
+  const dir = (0, import_node_path2.dirname)(filePath);
+  if (!(0, import_node_fs2.existsSync)(dir)) {
+    (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
+  }
+  const existing = (0, import_node_fs2.existsSync)(filePath) ? parseEnvFile(filePath) : {};
+  const merged = { ...existing, ...values };
+  const lines = Object.entries(merged).filter(([, v]) => v !== "").map(([k, v]) => `${k}=${v}`);
+  (0, import_node_fs2.writeFileSync)(filePath, lines.join("\n") + "\n", "utf-8");
+}
+async function httpJson(method, url, apiKey, body) {
+  const headers = { "Content-Type": "application/json" };
+  if (apiKey) headers["Authorization"] = `Bearer ${apiKey}`;
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body !== void 0 ? JSON.stringify(body) : void 0
+  });
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    data = {};
+  }
+  return { status: response.status, data };
+}
+function openInBrowser(url) {
+  const { execSync } = require("child_process");
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") execSync(`open "${url}"`);
+    else if (platform === "win32") execSync(`start "" "${url}"`);
+    else execSync(`xdg-open "${url}"`);
+  } catch {
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function handleRegister(args) {
+  const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+  let orgName = "";
+  let agentName = "";
+  let noWait = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--org-name" && args[i + 1]) orgName = args[++i];
+    else if (args[i] === "--agent-name" && args[i + 1]) agentName = args[++i];
+    else if (args[i] === "--no-wait") noWait = true;
+  }
+  if (!agentName) {
+    try {
+      agentName = (0, import_node_os3.hostname)() || "Deepline CLI (TS)";
+    } catch {
+      agentName = "Deepline CLI (TS)";
+    }
+  }
+  const payload = {};
+  if (orgName) payload.org_name = orgName;
+  if (agentName) payload.agent_name = agentName;
+  const { status, data } = await httpJson("POST", `${baseUrl}/api/v2/auth/cli/register`, null, payload);
+  if (status >= 400) {
+    console.error(`Auth register failed (status ${status}).`);
+    if (data.error) console.error(String(data.error));
+    return EXIT_SERVER;
+  }
+  const claimUrl = String(data.claim_url || "");
+  const claimToken = String(data.claim_token || "");
+  if (claimToken) {
+    saveEnvValues({ DEEPLINE_CLAIM_TOKEN: claimToken }, baseUrl);
+  }
+  if (claimUrl) {
+    console.log("  Opening approval page in your browser.");
+    console.log(`  If it didn't open, cmd+click: ${claimUrl}`);
+    openInBrowser(claimUrl);
+  }
+  if (data.cli_message) {
+    console.log(String(data.cli_message));
+  }
+  if (noWait) return EXIT_OK;
+  if (!claimToken) {
+    console.error("Missing claim token from register response.");
+    return EXIT_SERVER;
+  }
+  while (true) {
+    const { status: s, data: statusData } = await httpJson(
+      "POST",
+      `${baseUrl}/api/v2/auth/cli/status`,
+      null,
+      { claim_token: claimToken, reveal: true }
+    );
+    if (s === 401 || s === 403) {
+      console.log("Status: unauthorized");
+      return EXIT_AUTH;
+    }
+    if (s >= 500 || s === 0 || s === 400) {
+      await sleep(2e3);
+      continue;
+    }
+    if (s >= 400) {
+      console.error(`Auth status error (status ${s}).`);
+      return EXIT_SERVER;
+    }
+    const state = String(statusData.status || "").toLowerCase();
+    if (state === "claimed") {
+      const apiKey = String(statusData.api_key || "");
+      if (apiKey) {
+        saveEnvValues({ DEEPLINE_API_KEY: apiKey, DEEPLINE_CLAIM_TOKEN: "" }, baseUrl);
+        console.log("");
+        console.log("DEEPLINE");
+        console.log("All set! Your CLI is connected.");
+        if (statusData.org_name) {
+          console.log(`  Signed in with organization: ${statusData.org_name}`);
+        }
+        return EXIT_OK;
+      }
+    }
+    if (state === "expired") {
+      console.log("That approval link expired. Please run: deepline auth register");
+      return EXIT_AUTH;
+    }
+    await sleep(2e3);
+  }
+}
+async function handleStatus(args) {
+  const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+  const reveal = args.includes("--reveal");
+  try {
+    const { status: hStatus, data: hData } = await httpJson("GET", `${baseUrl}/api/v2/health`, null);
+    if (hStatus === 200) {
+      console.log(`Host: ${baseUrl}`);
+      console.log(`Host status: ${hData.status || "ok"}`);
+      console.log(`Host version: ${hData.version || "(unknown)"}`);
+    }
+  } catch {
+    console.log(`Host: ${baseUrl} (unreachable)`);
+  }
+  const env = loadCliEnv(baseUrl);
+  const apiKey = process.env.DEEPLINE_API_KEY?.trim() || env.DEEPLINE_API_KEY || "";
+  if (!apiKey) {
+    console.log("Status: not connected");
+    console.log("Run: deepline auth register");
+    return EXIT_OK;
+  }
+  const { status, data } = await httpJson("POST", `${baseUrl}/api/v2/auth/cli/status`, apiKey, {
+    api_key: apiKey,
+    reveal
+  });
+  if (status === 401 || status === 403) {
+    console.log("Status: unauthorized");
+    console.log("Run: deepline auth register");
+    return EXIT_AUTH;
+  }
+  if (status >= 400) {
+    console.error(`Auth status error (status ${status}).`);
+    return EXIT_SERVER;
+  }
+  console.log(`Status: ${data.status || "(unknown)"}`);
+  console.log(`Rate limit tier: ${data.rate_limit_tier || "(unknown)"}`);
+  if (data.org_name) console.log(`Workspace: ${data.org_name}`);
+  if (data.org_slug) console.log(`Workspace slug: ${data.org_slug}`);
+  if (data.org_id != null) console.log(`Org ID: ${data.org_id}`);
+  if (data.user_id != null) console.log(`User ID: ${data.user_id}`);
+  if (reveal) {
+    const apiKeyResp = String(data.api_key || apiKey);
+    if (apiKeyResp) {
+      saveEnvValues({ DEEPLINE_API_KEY: apiKeyResp, DEEPLINE_CLAIM_TOKEN: "" }, baseUrl);
+      console.log(`Saved API key to ${envFilePath(baseUrl)}`);
+    }
+  }
+  return EXIT_OK;
+}
+async function handleAuth(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "register":
+      return handleRegister(subArgs);
+    case "status":
+      return handleStatus(subArgs);
+    default:
+      return handleStatus(args);
+  }
+}
+
+// src/http.ts
+var SDK_VERSION = "0.1.0";
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async request(path, options) {
+    const url = `${this.config.baseUrl}${path}`;
+    const method = options?.method ?? "GET";
+    const headers = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
+      ...options?.headers
+    };
+    if (options?.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const backoffMs = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
+        await sleep2(backoffMs);
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        options?.timeout ?? this.config.timeout
+      );
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 401 || response.status === 403) {
+          throw new AuthError();
+        }
+        if (response.status === 429) {
+          const retryAfter = parseRetryAfter(response);
+          lastError = new RateLimitError(retryAfter);
+          if (attempt < this.config.maxRetries) continue;
+          throw lastError;
+        }
+        const body = await response.text();
+        let parsed;
+        try {
+          parsed = JSON.parse(body);
+        } catch {
+          parsed = body;
+        }
+        if (!response.ok) {
+          const msg = typeof parsed === "object" && parsed && "error" in parsed ? String(parsed.error) : `HTTP ${response.status}`;
+          throw new DeeplineError(msg, response.status, "API_ERROR", {
+            response: parsed
+          });
+        }
+        return parsed;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        if (error instanceof AuthError || error instanceof DeeplineError) {
+          throw error;
+        }
+        if (error instanceof RateLimitError) {
+          lastError = error;
+          if (attempt < this.config.maxRetries) continue;
+          throw error;
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt < this.config.maxRetries) continue;
+      }
+    }
+    throw lastError ?? new DeeplineError("Request failed after retries");
+  }
+  async get(path) {
+    return this.request(path, { method: "GET" });
+  }
+  async post(path, body) {
+    return this.request(path, { method: "POST", body });
+  }
+};
+function parseRetryAfter(response) {
+  const header = response.headers.get("retry-after");
+  if (header) {
+    const seconds = Number(header);
+    if (Number.isFinite(seconds) && seconds > 0) {
+      return seconds * 1e3;
+    }
+  }
+  return 5e3;
+}
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/client.ts
+var DeeplineClient = class {
+  http;
+  config;
+  constructor(options) {
+    this.config = resolveConfig(options);
+    this.http = new HttpClient(this.config);
+  }
+  get baseUrl() {
+    return this.config.baseUrl;
+  }
+  /** List available tools. */
+  async listTools() {
+    const res = await this.http.get("/api/v2/tools");
+    return res.tools;
+  }
+  /** Execute a single tool. */
+  async executeTool(toolId, input) {
+    const res = await this.http.post(
+      `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
+      { payload: input }
+    );
+    return res.result ?? res;
+  }
+  /**
+   * Submit a play for cloud execution.
+   * Returns a workflowId. Use pollPlay() to get status.
+   */
+  async submitPlay(code, csvPath, name) {
+    return this.http.post("/api/v2/plays/run", {
+      code,
+      csvPath,
+      name
+    });
+  }
+  /** Poll workflow status. */
+  async getPlayStatus(workflowId) {
+    return this.http.get(`/api/v2/plays/run/${workflowId}`);
+  }
+  /** Cancel a running play. */
+  async cancelPlay(workflowId) {
+    await this.http.request(`/api/v2/plays/run/${workflowId}`, { method: "DELETE" });
+  }
+  /**
+   * Run a play end-to-end: submit, poll until done, return result.
+   * onProgress is called on each poll with current status.
+   */
+  async runPlay(code, csvPath, name, options) {
+    const { workflowId } = await this.submitPlay(code, csvPath, name);
+    const pollInterval = options?.pollIntervalMs ?? 2e3;
+    const start = Date.now();
+    while (true) {
+      if (options?.signal?.aborted) {
+        await this.cancelPlay(workflowId);
+        return {
+          success: false,
+          workflowId,
+          logs: [],
+          durationMs: Date.now() - start,
+          error: "Cancelled by user"
+        };
+      }
+      const status = await this.getPlayStatus(workflowId);
+      options?.onProgress?.(status);
+      const terminal = ["COMPLETED", "FAILED", "CANCELLED", "TERMINATED", "TIMED_OUT"];
+      if (terminal.includes(status.temporalStatus)) {
+        return {
+          success: status.temporalStatus === "COMPLETED",
+          workflowId,
+          result: status.result,
+          logs: status.progress?.logs ?? [],
+          durationMs: Date.now() - start,
+          error: status.progress?.error ?? (status.temporalStatus !== "COMPLETED" ? status.temporalStatus : void 0)
+        };
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+    }
+  }
+  /** Health check. */
+  async health() {
+    return this.http.get("/api/v2/health");
+  }
+};
+
+// src/cli/commands/tools.ts
+async function handleTools(args) {
+  const subcommand = args[0];
+  const subArgs = args.slice(1);
+  switch (subcommand) {
+    case "list":
+      return listTools();
+    case "execute":
+    case "run":
+      return executeTool(subArgs);
+    default:
+      return listTools();
+  }
+}
+async function listTools() {
+  const dl = new DeeplineClient();
+  const tools = await dl.listTools();
+  console.log(`${tools.length} tools available:
+`);
+  for (const tool of tools) {
+    const cats = tool.categories.length ? ` [${tool.categories.join(", ")}]` : "";
+    console.log(`  ${tool.toolId}${cats}`);
+    console.log(`    ${tool.description}`);
+  }
+  return 0;
+}
+async function executeTool(args) {
+  const toolId = args[0];
+  if (!toolId) {
+    console.error(`Usage: deepline tools execute <toolId> [--param key=value ...] [--json '{"k":"v"}']`);
+    return 1;
+  }
+  const params = {};
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--param" || arg === "-p") && args[i + 1]) {
+      const kv = args[++i];
+      const eqIdx = kv.indexOf("=");
+      if (eqIdx > 0) params[kv.slice(0, eqIdx)] = kv.slice(eqIdx + 1);
+    } else if (arg === "--json" && args[i + 1]) {
+      Object.assign(params, JSON.parse(args[++i]));
+    }
+  }
+  const dl = new DeeplineClient();
+  const result = await dl.executeTool(toolId, params);
+  console.log(JSON.stringify(result, null, 2));
+  return 0;
+}
+
+// src/cli/commands/play.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
+function camelToKebab(str) {
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function extractPlayName(code, filePath) {
+  const nameMatch = code.match(/export\s+default\s+async\s+function\s+(\w+)/);
+  if (nameMatch?.[1]) {
+    return camelToKebab(nameMatch[1]);
+  }
+  const base = (0, import_node_path3.basename)(filePath).replace(/\.(play\.)?(ts|js|mjs)$/, "");
+  return base.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
+}
+async function handlePlay(args) {
+  const playPath = args[0];
+  if (!playPath) {
+    console.error("Usage: deepline play <play-file.ts> --csv <file.csv>");
+    return 1;
+  }
+  let csvPath = "";
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--csv" || arg === "--input" || arg === "-i") && args[i + 1]) {
+      csvPath = (0, import_node_path3.resolve)(args[++i]);
+    }
+  }
+  const absPlayPath = (0, import_node_path3.resolve)(playPath);
+  let code;
+  try {
+    code = (0, import_node_fs3.readFileSync)(absPlayPath, "utf-8");
+  } catch {
+    console.error(`Cannot read play file: ${absPlayPath}`);
+    return 1;
+  }
+  const playName = extractPlayName(code, absPlayPath);
+  const fnMatch = code.match(
+    /export\s+default\s+(async\s+function\s*\w*\s*\([^)]*\)\s*\{[\s\S]*\})/
+  );
+  const playCode = fnMatch ? fnMatch[1] : code;
+  if (!csvPath) {
+    const csvArg = args.find((a) => a.endsWith(".csv"));
+    if (csvArg) csvPath = (0, import_node_path3.resolve)(csvArg);
+  }
+  if (!csvPath) {
+    console.error("CSV path required: --csv <file.csv>");
+    return 1;
+  }
+  const dl = new DeeplineClient();
+  const controller = new AbortController();
+  const onSigint = () => {
+    console.log("\nCancelling play...");
+    controller.abort();
+  };
+  process.on("SIGINT", onSigint);
+  let lastLogIndex = 0;
+  try {
+    console.log(`Submitting play: ${playPath} (${playName})`);
+    console.log(`CSV: ${csvPath}`);
+    console.log(`Server: ${dl.baseUrl}`);
+    console.log("");
+    const result = await dl.runPlay(playCode, csvPath, playName, {
+      signal: controller.signal,
+      pollIntervalMs: 1500,
+      onProgress: (status) => {
+        const logs = status.progress?.logs ?? [];
+        for (let i = lastLogIndex; i < logs.length; i++) {
+          console.log(logs[i]);
+        }
+        lastLogIndex = logs.length;
+        if (status.progress?.status) {
+          process.stdout.write(
+            `\r  [${status.progress.status}]${status.progress.totalRows ? ` ${status.progress.totalRows} rows` : ""}`
+          );
+        }
+      }
+    });
+    console.log("");
+    if (result.success) {
+      console.log(`
+Play completed in ${(result.durationMs / 1e3).toFixed(1)}s`);
+      if (result.result) {
+        const r = result.result;
+        if (r.rows && Array.isArray(r.rows)) {
+          console.log(`  ${r.rows.length} rows output`);
+        }
+        if (r.stats) {
+          console.log(`  Stats: ${JSON.stringify(r.stats)}`);
+        }
+      }
+      return 0;
+    } else {
+      console.error(`
+Play failed: ${result.error}`);
+      return 1;
+    }
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+
+// src/cli/commands/enrich.ts
+async function handleEnrich(args) {
+  console.log("Note: `enrich` runs via the play engine. Use `deepline play` directly.");
+  console.log("");
+  return handlePlay(args);
+}
+
+// src/cli/index.ts
+var VERSION = "0.0.1";
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const subArgs = args.slice(1);
+  let exitCode = 0;
+  try {
+    switch (command) {
+      case "auth":
+        exitCode = await handleAuth(subArgs);
+        break;
+      case "tools":
+        exitCode = await handleTools(subArgs);
+        break;
+      case "enrich":
+        exitCode = await handleEnrich(subArgs);
+        break;
+      case "play":
+        exitCode = await handlePlay(subArgs);
+        break;
+      case "health": {
+        const baseUrl = detectBaseUrl();
+        try {
+          const res = await fetch(`${baseUrl}/api/v2/health`);
+          const data = await res.json();
+          console.log(JSON.stringify(data, null, 2));
+        } catch (error) {
+          console.error(`Cannot reach ${baseUrl}: ${error instanceof Error ? error.message : error}`);
+          exitCode = 1;
+        }
+        break;
+      }
+      case "version":
+      case "--version":
+      case "-v":
+        console.log(`deepline ${VERSION}`);
+        break;
+      case "help":
+      case "--help":
+      case "-h":
+      case void 0:
+        printHelp();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        exitCode = 1;
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error(`Error: ${error}`);
+    }
+    exitCode = 1;
+  }
+  process.exit(exitCode);
+}
+function detectBaseUrl() {
+  if (process.env.DEEPLINE_API_BASE_URL) {
+    return process.env.DEEPLINE_API_BASE_URL.replace(/\/$/, "");
+  }
+  return "https://code.deepline.com";
+}
+function printHelp() {
+  console.log(`
+deepline \u2014 Deepline CLI (TypeScript SDK)
+
+Usage:
+  deepline <command> [options]
+
+Commands:
+  auth register    Register this device (opens browser for approval)
+  auth status      Show connection status
+  tools list       List available tools
+  tools execute    Execute a tool
+  tools find       Find a tool by name
+  enrich           Run CSV enrichment pipeline
+  play             Run a play file
+  health           Check server health
+  version          Show version
+
+Options:
+  --help, -h       Show this help
+  --version, -v    Show version
+
+Examples:
+  deepline auth register
+  deepline tools list
+  deepline tools execute apollo_searchPeople --param domain=anthropic.com
+  deepline play enrich-leads.play.ts --input file=leads.csv
+`.trim());
+}
+main();
+//# sourceMappingURL=index.js.map