@koderlabs/tasks-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1011 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import { Command } from "commander";
+import pc8 from "picocolors";
+
+// src/api.ts
+var ApiError = class extends Error {
+  static {
+    __name(this, "ApiError");
+  }
+  status;
+  body;
+  constructor(status, message, body) {
+    super(message), this.status = status, this.body = body;
+    this.name = "ApiError";
+  }
+};
+var ApiClient = class {
+  static {
+    __name(this, "ApiClient");
+  }
+  apiUrl;
+  key;
+  fetchImpl;
+  maxRetries;
+  retryBaseMs;
+  constructor(opts) {
+    this.apiUrl = opts.apiUrl.replace(/\/+$/, "");
+    this.key = opts.key;
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.retryBaseMs = opts.retryBaseMs ?? 500;
+    if (!this.fetchImpl) {
+      throw new Error("No fetch implementation available. Use Node >= 18.");
+    }
+  }
+  /** Upload one or more source-map artifacts to a release. */
+  async uploadSourceMaps(version, environment, files) {
+    const url = `${this.apiUrl}/sdk/source-maps?version=${encodeURIComponent(version)}&environment=${encodeURIComponent(environment)}`;
+    const form = new FormData();
+    for (const f of files) {
+      const bytes = toUint8(f.content);
+      const blob = new Blob([
+        bytes
+      ], {
+        type: "application/json"
+      });
+      form.append("files", blob, f.filename);
+    }
+    return this.request("POST", url, form);
+  }
+  /** Create (or upsert) a release without uploading any artifacts. */
+  async createRelease(version, environment) {
+    return this.uploadSourceMaps(version, environment, []);
+  }
+  async request(method, url, body) {
+    let attempt = 0;
+    let lastErr;
+    while (attempt <= this.maxRetries) {
+      try {
+        const res = await this.fetchImpl(url, {
+          method,
+          headers: {
+            authorization: `Bearer ${this.key}`
+          },
+          body
+        });
+        if (res.status === 401 || res.status === 403) {
+          const txt = await safeText(res);
+          throw new ApiError(res.status, `Authentication failed (HTTP ${res.status}). Check your management key. ${txt}`.trim(), txt);
+        }
+        if (res.status === 429 || res.status >= 500) {
+          const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
+          if (attempt < this.maxRetries) {
+            const wait2 = retryAfter ?? this.retryBaseMs * Math.pow(2, attempt);
+            await sleep(wait2);
+            attempt++;
+            continue;
+          }
+          const txt = await safeText(res);
+          throw new ApiError(res.status, `HTTP ${res.status} after ${attempt + 1} attempts. ${txt}`.trim(), txt);
+        }
+        if (!res.ok) {
+          const txt = await safeText(res);
+          throw new ApiError(res.status, `HTTP ${res.status}: ${txt}`.trim(), txt);
+        }
+        const json = await res.json();
+        return json && typeof json === "object" && "data" in json ? json.data : json;
+      } catch (err) {
+        if (err instanceof ApiError && err.status !== 429 && err.status < 500) throw err;
+        lastErr = err;
+        if (attempt >= this.maxRetries) throw err;
+        await sleep(this.retryBaseMs * Math.pow(2, attempt));
+        attempt++;
+      }
+    }
+    throw lastErr ?? new Error("Unreachable");
+  }
+};
+function toUint8(content) {
+  if (content instanceof Uint8Array) return content;
+  return new Uint8Array(content);
+}
+__name(toUint8, "toUint8");
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+__name(safeText, "safeText");
+function parseRetryAfter(header) {
+  if (!header) return null;
+  const n = Number(header);
+  if (Number.isFinite(n) && n >= 0) return n * 1e3;
+  const date = Date.parse(header);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+__name(parseRetryAfter, "parseRetryAfter");
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+__name(sleep, "sleep");
+
+// src/config.ts
+import { existsSync, readFileSync } from "fs";
+import * as path from "path";
+var DEFAULT_API_URL = "http://localhost:11002/api/v1";
+var RC_FILENAME = ".tasksrc.json";
+function findRcFile(start) {
+  let dir = path.resolve(start);
+  while (true) {
+    const candidate = path.join(dir, RC_FILENAME);
+    if (existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+__name(findRcFile, "findRcFile");
+function loadRc(start) {
+  const file = findRcFile(start);
+  if (!file) return {
+    data: {}
+  };
+  try {
+    const data = JSON.parse(readFileSync(file, "utf-8"));
+    return {
+      file,
+      data
+    };
+  } catch {
+    return {
+      file,
+      data: {}
+    };
+  }
+}
+__name(loadRc, "loadRc");
+function resolveConfig(input = {}, env = process.env) {
+  const { file: rcFile, data: rc } = loadRc(input.cwd ?? process.cwd());
+  const apiUrl = (input.apiUrl ?? env.INSTANTTASKS_ENDPOINT ?? env.INSTANTTASKS_API_URL ?? rc.endpoint ?? rc.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, "");
+  const key = input.key ?? env.INSTANTTASKS_INGEST_KEY ?? env.INSTANTTASKS_MANAGEMENT_KEY ?? rc.ingestKey ?? rc.key ?? "";
+  const projectId = input.projectId ?? env.INSTANTTASKS_PROJECT_ID ?? rc.projectId;
+  if (!key && !input.optionalKey) {
+    throw new Error("Missing key. Pass --key sk_live_... / pk_live_..., set INSTANTTASKS_INGEST_KEY, or add it to .tasksrc.json.");
+  }
+  if (key && !/^(sk|pk)_/.test(key)) {
+    throw new Error(`Invalid key format: expected sk_live_... / pk_live_..., got "${key.slice(0, 6)}\u2026".`);
+  }
+  return {
+    apiUrl,
+    key,
+    projectId,
+    rcFile
+  };
+}
+__name(resolveConfig, "resolveConfig");
+
+// src/commands/upload-sourcemaps.ts
+import { promises as fs } from "fs";
+import * as path2 from "path";
+import pc from "picocolors";
+async function uploadSourcemaps(opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const env = opts.environment ?? "production";
+  const root = path2.resolve(opts.dir);
+  const maps = await walkForMaps(root);
+  if (maps.length === 0) {
+    log(pc.yellow(`No .js.map files found under ${root}`));
+    return 0;
+  }
+  log(pc.cyan(`Uploading ${maps.length} source map(s) to release ${opts.release} (${env})\u2026`));
+  const files = [];
+  for (const absPath of maps) {
+    const rel = path2.relative(root, absPath).split(path2.sep).join("/");
+    const url = opts.urlPrefix ? joinUrl(opts.urlPrefix, rel.replace(/\.map$/, "")) : void 0;
+    const content = await fs.readFile(absPath);
+    files.push({
+      filename: path2.basename(absPath),
+      url,
+      content
+    });
+    log(`  ${pc.dim("\u2192")} ${rel}${url ? pc.dim(`  (${url})`) : ""}`);
+  }
+  const result = await opts.apiClient.uploadSourceMaps(opts.release, env, files);
+  log(pc.green(`Done. Release ${result.release.version} now has ${result.uploaded.length} artifact(s).`));
+  return result.uploaded.length;
+}
+__name(uploadSourcemaps, "uploadSourcemaps");
+async function walkForMaps(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await fs.readdir(dir, {
+      withFileTypes: true
+    });
+  } catch (err) {
+    throw new Error(`Cannot read directory ${dir}: ${err.message}`);
+  }
+  for (const entry of entries) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await walkForMaps(full);
+      out.push(...nested);
+    } else if (entry.isFile() && entry.name.endsWith(".js.map")) {
+      out.push(full);
+    }
+  }
+  return out.sort();
+}
+__name(walkForMaps, "walkForMaps");
+function joinUrl(prefix, rel) {
+  const left = prefix.replace(/\/+$/, "");
+  const right = rel.replace(/^\/+/, "");
+  return `${left}/${right}`;
+}
+__name(joinUrl, "joinUrl");
+
+// src/commands/releases.ts
+import pc2 from "picocolors";
+async function createRelease(opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const env = opts.environment ?? "production";
+  log(pc2.cyan(`Creating release ${opts.name} (${env})\u2026`));
+  const result = await opts.apiClient.createRelease(opts.name, env);
+  log(pc2.green(`Release ${result.release.version} ready (id=${result.release.id}).`));
+  return result.release.id;
+}
+__name(createRelease, "createRelease");
+
+// src/commands/doctor.ts
+import pc3 from "picocolors";
+async function doctor(opts = {}) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const checks = [];
+  let cfg;
+  try {
+    cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key,
+      projectId: opts.projectId
+    });
+    checks.push({
+      name: "config",
+      ok: true,
+      detail: `endpoint=${cfg.apiUrl}${cfg.rcFile ? ` (rc=${cfg.rcFile})` : ""}`
+    });
+  } catch (err) {
+    checks.push({
+      name: "config",
+      ok: false,
+      detail: err.message
+    });
+    return finish(checks, log);
+  }
+  if (!cfg.projectId) {
+    checks.push({
+      name: "projectId",
+      ok: false,
+      detail: "INSTANTTASKS_PROJECT_ID not set (some commands require it)."
+    });
+  } else {
+    checks.push({
+      name: "projectId",
+      ok: true,
+      detail: cfg.projectId
+    });
+  }
+  const configUrl = `${cfg.apiUrl}/sdk/v1/config`;
+  try {
+    const res = await fetchImpl(configUrl, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${cfg.key}`
+      }
+    });
+    if (res.ok) {
+      checks.push({
+        name: "endpoint",
+        ok: true,
+        detail: `${configUrl} \u2192 ${res.status}`
+      });
+      checks.push({
+        name: "ingestKey",
+        ok: true,
+        detail: "authenticated"
+      });
+    } else if (res.status === 401 || res.status === 403) {
+      checks.push({
+        name: "endpoint",
+        ok: true,
+        detail: `${configUrl} reachable (${res.status})`
+      });
+      checks.push({
+        name: "ingestKey",
+        ok: false,
+        detail: `key rejected (HTTP ${res.status}) \u2014 check INSTANTTASKS_INGEST_KEY`
+      });
+    } else {
+      checks.push({
+        name: "endpoint",
+        ok: false,
+        detail: `${configUrl} \u2192 HTTP ${res.status}`
+      });
+    }
+  } catch (err) {
+    checks.push({
+      name: "endpoint",
+      ok: false,
+      detail: `cannot reach ${configUrl}: ${err.message}`
+    });
+  }
+  if (cfg.key.startsWith("pk_")) {
+    checks.push({
+      name: "sourcemapPermission",
+      ok: false,
+      detail: "pk_ keys cannot upload source maps \u2014 use sk_live_... for CI uploads"
+    });
+  } else if (cfg.key.startsWith("sk_")) {
+    checks.push({
+      name: "sourcemapPermission",
+      ok: true,
+      detail: "sk_ key has upload role"
+    });
+  }
+  return finish(checks, log);
+}
+__name(doctor, "doctor");
+function finish(checks, log) {
+  for (const c of checks) {
+    const mark = c.ok ? pc3.green("\u2713") : pc3.red("\u2717");
+    log(`  ${mark} ${pc3.bold(c.name.padEnd(20))} ${c.ok ? pc3.dim(c.detail) : pc3.yellow(c.detail)}`);
+  }
+  const ok = checks.every((c) => c.ok);
+  log("");
+  log(ok ? pc3.green("All checks passed.") : pc3.red("One or more checks failed."));
+  return {
+    ok,
+    checks
+  };
+}
+__name(finish, "finish");
+
+// src/commands/sourcemap-upload.ts
+import { promises as fs2 } from "fs";
+import * as path3 from "path";
+import pc4 from "picocolors";
+var DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS = 500;
+async function sourcemapUpload(opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES;
+  const strict = opts.strict !== false;
+  const root = path3.resolve(opts.dist);
+  const maps = await walk(root);
+  if (maps.length === 0) {
+    log(pc4.yellow(`No .map files found under ${root}`));
+    return {
+      uploaded: 0,
+      failed: 0,
+      skipped: 0
+    };
+  }
+  log(pc4.cyan(`Uploading ${maps.length} source map(s)${opts.release ? ` for release ${opts.release}` : ""}\u2026`));
+  let uploaded = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const absPath of maps) {
+    const safe = safeRelative(root, absPath);
+    if (!safe) {
+      log(pc4.red(`  \u2717 ${absPath} \u2014 path escapes dist root`));
+      failed++;
+      continue;
+    }
+    const stat = await fs2.stat(absPath);
+    if (stat.size > maxBytes) {
+      log(pc4.yellow(`  \u26A0 ${safe} \u2014 ${stat.size} bytes exceeds cap ${maxBytes}, skipping`));
+      skipped++;
+      continue;
+    }
+    const content = await fs2.readFile(absPath, "utf-8");
+    const ok = await postWithRetry(fetchImpl, opts.apiUrl, opts.key, {
+      path: safe,
+      content,
+      release: opts.release,
+      environment: opts.environment
+    });
+    if (ok.ok) {
+      log(`  ${pc4.green("\u2713")} ${safe}`);
+      uploaded++;
+    } else {
+      log(pc4.red(`  \u2717 ${safe} \u2014 ${ok.detail}`));
+      failed++;
+    }
+  }
+  log("");
+  log(`${pc4.bold("Summary:")} ${pc4.green(`${uploaded} uploaded`)}, ${failed ? pc4.red(`${failed} failed`) : `${failed} failed`}, ${skipped} skipped.`);
+  if (failed > 0 && strict) {
+    throw new Error(`${failed} source-map upload(s) failed (use --no-strict to ignore).`);
+  }
+  return {
+    uploaded,
+    failed,
+    skipped
+  };
+}
+__name(sourcemapUpload, "sourcemapUpload");
+function safeRelative(root, abs) {
+  const resolvedRoot = path3.resolve(root);
+  const resolved = path3.resolve(abs);
+  if (!resolved.startsWith(resolvedRoot + path3.sep) && resolved !== resolvedRoot) return null;
+  const rel = path3.relative(resolvedRoot, resolved);
+  if (!rel || rel.startsWith("..") || path3.isAbsolute(rel)) return null;
+  return rel.split(path3.sep).join("/");
+}
+__name(safeRelative, "safeRelative");
+async function walk(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await fs2.readdir(dir, {
+      withFileTypes: true
+    });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const full = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await walk(full));
+    } else if (entry.isFile() && entry.name.endsWith(".map")) {
+      out.push(full);
+    }
+  }
+  return out.sort();
+}
+__name(walk, "walk");
+async function postWithRetry(fetchImpl, apiUrl, key, body) {
+  const url = `${apiUrl.replace(/\/+$/, "")}/sdk/source-maps`;
+  let lastDetail = "unknown";
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${key}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (res.ok) return {
+        ok: true,
+        detail: `HTTP ${res.status}`
+      };
+      lastDetail = `HTTP ${res.status}`;
+      if (res.status !== 429 && (res.status < 500 || res.status >= 600)) {
+        return {
+          ok: false,
+          detail: lastDetail
+        };
+      }
+    } catch (err) {
+      lastDetail = err.message;
+    }
+    if (attempt < MAX_RETRIES) {
+      await new Promise((r) => setTimeout(r, RETRY_BASE_MS * Math.pow(2, attempt)));
+    }
+  }
+  return {
+    ok: false,
+    detail: lastDetail
+  };
+}
+__name(postWithRetry, "postWithRetry");
+
+// src/commands/symbols-upload.ts
+import { promises as fs3 } from "fs";
+import * as path4 from "path";
+import pc5 from "picocolors";
+var NATIVE_SYMBOLS_PATH = "/sdk/native-symbols";
+async function uploadIos(dsymPath, opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const root = path4.resolve(dsymPath);
+  if (!root.endsWith(".dSYM")) {
+    log(pc5.yellow(`Warning: ${root} does not end in .dSYM \u2014 proceeding anyway.`));
+  }
+  const dwarfRoot = path4.join(root, "Contents", "Resources", "DWARF");
+  const files = await listFiles(dwarfRoot);
+  if (files.length === 0) {
+    log(pc5.yellow(`No DWARF files found under ${dwarfRoot}`));
+    return {
+      uploaded: 0,
+      failed: 0,
+      endpointMissing: false
+    };
+  }
+  log(pc5.cyan(`Uploading ${files.length} iOS symbol file(s)\u2026`));
+  return uploadAll(files, "ios", opts, log);
+}
+__name(uploadIos, "uploadIos");
+async function uploadAndroid(mappingPath, opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const resolved = path4.resolve(mappingPath);
+  const stat = await fs3.stat(resolved).catch(() => null);
+  if (!stat?.isFile()) {
+    throw new Error(`mapping.txt not found at ${resolved}`);
+  }
+  log(pc5.cyan(`Uploading Android mapping ${resolved}\u2026`));
+  return uploadAll([
+    resolved
+  ], "android", opts, log);
+}
+__name(uploadAndroid, "uploadAndroid");
+async function uploadAll(files, platform, opts, log) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const url = `${opts.apiUrl.replace(/\/+$/, "")}${NATIVE_SYMBOLS_PATH}`;
+  let uploaded = 0;
+  let failed = 0;
+  let endpointMissing = false;
+  for (const file of files) {
+    const content = await fs3.readFile(file);
+    const body = {
+      platform,
+      filename: path4.basename(file),
+      release: opts.release,
+      // Base64-encoded so binary DWARFs survive JSON transport.
+      contentBase64: content.toString("base64")
+    };
+    try {
+      const res = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${opts.key}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (res.status === 404) {
+        endpointMissing = true;
+        log(pc5.yellow(`  \u26A0 ${path4.basename(file)} \u2014 endpoint pending (${NATIVE_SYMBOLS_PATH} returned 404)`));
+      } else if (res.ok) {
+        log(`  ${pc5.green("\u2713")} ${path4.basename(file)}`);
+        uploaded++;
+      } else {
+        log(pc5.red(`  \u2717 ${path4.basename(file)} \u2014 HTTP ${res.status}`));
+        failed++;
+      }
+    } catch (err) {
+      log(pc5.red(`  \u2717 ${path4.basename(file)} \u2014 ${err.message}`));
+      failed++;
+    }
+  }
+  if (endpointMissing) {
+    log("");
+    log(pc5.yellow(`Backend resolver pending: ${NATIVE_SYMBOLS_PATH} is not yet implemented. Symbol files were prepared but not stored server-side.`));
+  }
+  return {
+    uploaded,
+    failed,
+    endpointMissing
+  };
+}
+__name(uploadAll, "uploadAll");
+async function listFiles(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await fs3.readdir(dir, {
+      withFileTypes: true
+    });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const full = path4.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listFiles(full));
+    } else if (entry.isFile()) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+__name(listFiles, "listFiles");
+
+// src/commands/init.ts
+import { promises as fs4 } from "fs";
+import * as path5 from "path";
+import pc6 from "picocolors";
+var SUPPORTED_PLATFORMS = [
+  "web",
+  "react",
+  "nextjs",
+  "vue",
+  "rn",
+  "nestjs"
+];
+var RC_TEMPLATE = `{
+  "endpoint": "https://tasks.koderlabs.net/api/v1",
+  "ingestKey": "pk_live_REPLACE_ME",
+  "projectId": "REPLACE_WITH_PROJECT_UUID"
+}
+`;
+var README_SNIPPET = `
+## InstantTasks SDK
+
+Run \`npx @koderlabs/tasks-cli doctor\` to verify your setup.
+
+Upload source maps in CI:
+
+\`\`\`sh
+npx @koderlabs/tasks-cli sourcemap upload ./dist --release "$GIT_SHA"
+\`\`\`
+`;
+function planInit(platform) {
+  const files = [
+    {
+      filepath: ".tasksrc.json",
+      contents: RC_TEMPLATE
+    },
+    {
+      filepath: "INSTANTTASKS.md",
+      contents: README_SNIPPET.trim() + "\n"
+    }
+  ];
+  files.push({
+    filepath: snippetPath(platform),
+    contents: snippetFor(platform)
+  });
+  return files;
+}
+__name(planInit, "planInit");
+function snippetPath(platform) {
+  switch (platform) {
+    case "web":
+      return "src/tasks-sdk.ts";
+    case "react":
+      return "src/tasks-sdk.ts";
+    case "nextjs":
+      return "instrumentation.ts";
+    case "vue":
+      return "src/tasks-sdk.ts";
+    case "rn":
+      return "src/tasks-sdk.ts";
+    case "nestjs":
+      return "src/tasks-sdk.ts";
+  }
+}
+__name(snippetPath, "snippetPath");
+function snippetFor(platform) {
+  switch (platform) {
+    case "web":
+    case "react":
+    case "vue":
+      return `import { init } from '@koderlabs/tasks-sdk-browser';
+
+init({
+  endpoint: import.meta.env.VITE_TASKS_ENDPOINT,
+  ingestKey: import.meta.env.VITE_TASKS_INGEST_KEY,
+  release: import.meta.env.VITE_RELEASE,
+});
+`;
+    case "nextjs":
+      return `// Next.js 13+ instrumentation hook \u2014 auto-loaded once per process.
+export async function register() {
+  const { init } = await import('@koderlabs/tasks-sdk-nextjs');
+  init({
+    endpoint: process.env.NEXT_PUBLIC_TASKS_ENDPOINT!,
+    ingestKey: process.env.NEXT_PUBLIC_TASKS_INGEST_KEY!,
+    release: process.env.NEXT_PUBLIC_RELEASE,
+  });
+}
+`;
+    case "rn":
+      return `import { init } from '@koderlabs/tasks-sdk-rn';
+
+init({
+  endpoint: process.env.EXPO_PUBLIC_TASKS_ENDPOINT!,
+  ingestKey: process.env.EXPO_PUBLIC_TASKS_INGEST_KEY!,
+  release: process.env.EXPO_PUBLIC_RELEASE,
+});
+`;
+    case "nestjs":
+      return `import { init } from '@koderlabs/tasks-sdk-node';
+
+init({
+  endpoint: process.env.INSTANTTASKS_ENDPOINT!,
+  ingestKey: process.env.INSTANTTASKS_INGEST_KEY!,
+  release: process.env.RELEASE,
+});
+`;
+  }
+}
+__name(snippetFor, "snippetFor");
+async function initScaffold(opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const cwd = path5.resolve(opts.cwd ?? process.cwd());
+  const files = planInit(opts.platform);
+  const written = [];
+  const skipped = [];
+  log(pc6.cyan(`Scaffolding InstantTasks for ${pc6.bold(opts.platform)}\u2026`));
+  for (const f of files) {
+    const abs = path5.join(cwd, f.filepath);
+    const exists = await fs4.stat(abs).then(() => true).catch(() => false);
+    if (opts.dryRun) {
+      log(pc6.dim(`  [dry-run] would write ${f.filepath}${exists ? " (overwrite)" : ""}`));
+      log(pc6.dim("  \u250C\u2500"));
+      for (const line of f.contents.split("\n")) log(pc6.dim(`  \u2502 ${line}`));
+      log(pc6.dim("  \u2514\u2500"));
+      continue;
+    }
+    if (exists && !opts.force) {
+      log(pc6.yellow(`  \u26A0 ${f.filepath} exists \u2014 skipping (pass --force to overwrite)`));
+      skipped.push(f.filepath);
+      continue;
+    }
+    await fs4.mkdir(path5.dirname(abs), {
+      recursive: true
+    });
+    await fs4.writeFile(abs, f.contents, "utf-8");
+    log(`  ${pc6.green("\u2713")} ${f.filepath}`);
+    written.push(f.filepath);
+  }
+  if (!opts.dryRun) {
+    log("");
+    log(pc6.green("Done. Edit .tasksrc.json with your project credentials, then run:"));
+    log(`  ${pc6.bold("npx @koderlabs/tasks-cli doctor")}`);
+  }
+  return {
+    files,
+    written,
+    skipped
+  };
+}
+__name(initScaffold, "initScaffold");
+
+// src/commands/events-tail.ts
+import pc7 from "picocolors";
+async function eventsTail(opts) {
+  const log = opts.log ?? ((s) => console.log(s));
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const interval = opts.intervalMs ?? 5e3;
+  let since = opts.since ?? Date.now();
+  log(pc7.cyan(`Tailing events (poll every ${interval}ms). Ctrl-C to exit.`));
+  while (!opts.signal?.aborted) {
+    const params = new URLSearchParams({
+      since: String(since)
+    });
+    if (opts.projectId) params.set("projectId", opts.projectId);
+    for (const [k, v] of Object.entries(opts.filter ?? {})) params.set(k, v);
+    const url = `${opts.apiUrl.replace(/\/+$/, "")}/sdk/v1/events?${params.toString()}`;
+    try {
+      const res = await fetchImpl(url, {
+        method: "GET",
+        headers: {
+          authorization: `Bearer ${opts.key}`
+        },
+        signal: opts.signal
+      });
+      if (res.status === 404) {
+        log(pc7.yellow(`events endpoint not available yet (404). Backend needs to ship /sdk/v1/events \u2014 exiting tail loop.`));
+        return;
+      }
+      if (res.ok) {
+        const body = await res.json();
+        const rows = Array.isArray(body) ? body : Array.isArray(body?.data) ? body.data : [];
+        for (const row of rows) {
+          const ts = typeof row.ts === "number" ? new Date(row.ts).toISOString() : String(row.ts);
+          const kind = row.kind ?? "event";
+          const message = row.message ?? "";
+          const url2 = row.url ? pc7.dim(` ${row.url}`) : "";
+          log(`${pc7.dim(ts)} | ${pc7.bold(kind.padEnd(12))} | ${message}${url2}`);
+          if (typeof row.ts === "number") since = Math.max(since, row.ts + 1);
+        }
+        if (rows.length === 0) {
+          since = Date.now();
+        }
+      } else {
+        log(pc7.yellow(`poll failed: HTTP ${res.status}`));
+      }
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      log(pc7.yellow(`poll error: ${err.message}`));
+    }
+    await wait(interval, opts.signal);
+  }
+}
+__name(eventsTail, "eventsTail");
+function wait(ms, signal) {
+  return new Promise((resolve6) => {
+    const t = setTimeout(resolve6, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve6();
+    });
+  });
+}
+__name(wait, "wait");
+function parseSince(input, now = Date.now()) {
+  if (!input) return now;
+  const match = input.match(/^(\d+)([smhd])$/);
+  if (!match) {
+    const n = Number(input);
+    return Number.isFinite(n) ? n : now;
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const mult = unit === "s" ? 1e3 : unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5;
+  return now - value * mult;
+}
+__name(parseSince, "parseSince");
+
+// src/index.ts
+var VERSION = "0.0.0";
+function buildProgram() {
+  const program = new Command();
+  program.name("tasks").description("InstantTasks CLI \u2014 doctor, source maps, symbols, init, events tail").version(VERSION);
+  program.command("doctor").description("Validate config + connectivity (CI-friendly; non-zero on failure)").option("--api-url <url>", "API base URL (defaults to env / .tasksrc.json)").option("--key <key>", "Ingest or management key").option("--project <id>", "Project ID").action(async (opts) => {
+    const result = await doctor({
+      apiUrl: opts.apiUrl,
+      key: opts.key,
+      projectId: opts.project
+    });
+    if (!result.ok) process.exit(1);
+  });
+  const sourcemap = program.command("sourcemap").description("Source-map utilities");
+  sourcemap.command("upload <dist>").description("Recursively upload .map files from a dist directory").option("--release <sha>", "Release name / version (associates maps with a release)").option("--environment <env>", "Release environment", "production").option("--max-size <bytes>", "Per-file size cap in bytes", String(50 * 1024 * 1024)).option("--no-strict", "Do not exit non-zero on individual file failures").option("--api-url <url>", "API base URL").option("--key <key>", "Management key (sk_live_...)").action(async (dist, opts) => {
+    const cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key
+    });
+    await sourcemapUpload({
+      dist,
+      apiUrl: cfg.apiUrl,
+      key: cfg.key,
+      release: opts.release,
+      environment: opts.environment,
+      maxBytes: Number(opts.maxSize),
+      strict: opts.strict !== false
+    });
+  });
+  const symbols = program.command("symbols").description("Native symbol uploads (iOS dSYM, Android ProGuard)");
+  symbols.command("upload-ios <dsym>").description("Upload DWARF files from a .dSYM bundle").option("--release <sha>", "Release name / version").option("--api-url <url>").option("--key <key>").action(async (dsym, opts) => {
+    const cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key
+    });
+    await uploadIos(dsym, {
+      apiUrl: cfg.apiUrl,
+      key: cfg.key,
+      release: opts.release
+    });
+  });
+  symbols.command("upload-android <mapping>").description("Upload an Android ProGuard mapping.txt").option("--release <sha>", "Release name / version").option("--api-url <url>").option("--key <key>").action(async (mapping, opts) => {
+    const cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key
+    });
+    await uploadAndroid(mapping, {
+      apiUrl: cfg.apiUrl,
+      key: cfg.key,
+      release: opts.release
+    });
+  });
+  program.command("init <platform>").description(`Scaffold .tasksrc.json + init snippet (platforms: ${SUPPORTED_PLATFORMS.join(", ")})`).option("--dry-run", "Print files that would be written but do not write them").option("--force", "Overwrite existing files").action(async (platform, opts) => {
+    if (!SUPPORTED_PLATFORMS.includes(platform)) {
+      throw new Error(`Unsupported platform "${platform}". Pick one of: ${SUPPORTED_PLATFORMS.join(", ")}`);
+    }
+    await initScaffold({
+      platform,
+      dryRun: opts.dryRun,
+      force: opts.force
+    });
+  });
+  const events = program.command("events").description("Event utilities");
+  events.command("tail").description("Stream recent SDK events (long-poll fallback until WebSocket lands)").option("--filter <kv...>", "Filter, e.g. project=<id>").option("--since <duration>", "Lookback window (e.g. 10m, 1h)").option("--interval <ms>", "Poll interval in ms", "5000").option("--api-url <url>").option("--key <key>").option("--project <id>").action(async (opts) => {
+    const cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key,
+      projectId: opts.project
+    });
+    const filter = {};
+    const rawFilters = Array.isArray(opts.filter) ? opts.filter : opts.filter ? [
+      opts.filter
+    ] : [];
+    for (const kv of rawFilters) {
+      const [k, v] = String(kv).split("=");
+      if (k && v) filter[k] = v;
+    }
+    const controller = new AbortController();
+    const onSig = /* @__PURE__ */ __name(() => {
+      console.log(pc8.dim("\n  (exiting)"));
+      controller.abort();
+    }, "onSig");
+    process.once("SIGINT", onSig);
+    process.once("SIGTERM", onSig);
+    await eventsTail({
+      apiUrl: cfg.apiUrl,
+      key: cfg.key,
+      projectId: cfg.projectId,
+      since: parseSince(opts.since),
+      intervalMs: Number(opts.interval) || 5e3,
+      filter,
+      signal: controller.signal
+    });
+  });
+  program.command("upload-sourcemaps").description("[legacy] Upload .js.map files in a directory to a release").requiredOption("--release <name>", "Release name / version").requiredOption("--dir <path>", "Directory to walk for *.js.map files").option("--environment <env>", "Release environment", "production").option("--url-prefix <prefix>", "Public URL prefix for source files").option("--project <projectId>").option("--api-url <url>").option("--key <key>").action(async (opts) => {
+    const cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key,
+      projectId: opts.project
+    });
+    const client = new ApiClient({
+      apiUrl: cfg.apiUrl,
+      key: cfg.key
+    });
+    await uploadSourcemaps({
+      release: opts.release,
+      dir: opts.dir,
+      environment: opts.environment,
+      urlPrefix: opts.urlPrefix,
+      apiClient: client
+    });
+  });
+  program.command("create-release").description("Create (or upsert) a release on the server").requiredOption("--name <name>", "Release name / version").option("--environment <env>", "Release environment", "production").option("--project <projectId>").option("--api-url <url>").option("--key <key>").action(async (opts) => {
+    const cfg = resolveConfig({
+      apiUrl: opts.apiUrl,
+      key: opts.key,
+      projectId: opts.project
+    });
+    const client = new ApiClient({
+      apiUrl: cfg.apiUrl,
+      key: cfg.key
+    });
+    await createRelease({
+      name: opts.name,
+      environment: opts.environment,
+      apiClient: client
+    });
+  });
+  return program;
+}
+__name(buildProgram, "buildProgram");
+async function main(argv = process.argv) {
+  const program = buildProgram();
+  program.exitOverride();
+  try {
+    await program.parseAsync(argv);
+    return 0;
+  } catch (err) {
+    if (err instanceof ApiError) {
+      console.error(pc8.red(`API error (${err.status}): ${err.message}`));
+      return 1;
+    }
+    const anyErr = err;
+    if (anyErr && typeof anyErr === "object" && "code" in anyErr) {
+      if (anyErr.code === "commander.helpDisplayed" || anyErr.code === "commander.version") return 0;
+      if (anyErr.code === "commander.help") return 0;
+    }
+    console.error(pc8.red(err.message || String(err)));
+    return 1;
+  }
+}
+__name(main, "main");
+var isEntry = (() => {
+  try {
+    const argv1 = process.argv[1] ?? "";
+    return /(?:^|[\\/])(tasks|instanttasks-cli|index\.[mc]?js)$/.test(argv1);
+  } catch {
+    return false;
+  }
+})();
+if (isEntry) {
+  main().then((code) => process.exit(code));
+}
+export {
+  buildProgram,
+  main
+};
+//# sourceMappingURL=index.js.map