@impractical-ai/motion 0.1.0 → 0.1.2

package/dist/chunk-G56RK3HD.js

@@ -0,0 +1,617 @@
+#!/usr/bin/env node
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/constants.ts
+var PRODUCTION_APP_URL = "https://motion.impractical.ai";
+var PRODUCTION_SUPABASE_URL = "https://uaxjweednprtbhbceify.supabase.co";
+var PACKAGE_NAME = "@impractical-ai/motion";
+var PACKAGE_VERSION = "0.1.2";
+var PACKAGE_COMMAND = `npx --yes ${PACKAGE_NAME}`;
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var configDir = () => join(homedir(), ".impractical");
+var configPath = () => join(configDir(), "config.json");
+function recoverCorruptConfig() {
+  const path = configPath();
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new SyntaxError("the root value must be an object");
+    }
+    return null;
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) {
+      throw new Error(
+        `Could not inspect ${path}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    let backupPath = `${path}.corrupt-${Date.now()}`;
+    let suffix = 1;
+    while (existsSync(backupPath)) backupPath = `${path}.corrupt-${Date.now()}-${suffix++}`;
+    renameSync(path, backupPath);
+    return backupPath;
+  }
+}
+function readStoredConfig() {
+  try {
+    const parsed = JSON.parse(readFileSync(configPath(), "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new SyntaxError("the root value must be an object");
+    }
+    return parsed;
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${configPath()}: ${error.message}`);
+    }
+    throw new Error(
+      `Could not read ${configPath()}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function loadConfig() {
+  const stored = readStoredConfig();
+  return {
+    apiKey: process.env.IMPRACTICAL_API_KEY ?? stored.apiKey,
+    supabaseUrl: process.env.IMPRACTICAL_SUPABASE_URL ?? stored.supabaseUrl ?? PRODUCTION_SUPABASE_URL,
+    appUrl: process.env.IMPRACTICAL_APP_URL ?? stored.appUrl ?? PRODUCTION_APP_URL
+  };
+}
+function saveConfig(patch) {
+  const stored = readStoredConfig();
+  const next = { ...stored, ...patch };
+  mkdirSync(configDir(), { recursive: true });
+  writeFileSync(configPath(), JSON.stringify(next, null, 2) + "\n");
+  chmodSync(configPath(), 384);
+  return next;
+}
+function requireConfig() {
+  const config = loadConfig();
+  if (!config.supabaseUrl) {
+    throw new Error("Not configured. Run: npx --yes @impractical-ai/motion setup --claude");
+  }
+  if (!config.apiKey) {
+    throw new Error("Not connected. Run: npx --yes @impractical-ai/motion setup --claude");
+  }
+  return config;
+}
+
+// src/api.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+var admissionContext = new AsyncLocalStorage();
+var ApiError = class extends Error {
+  constructor(status, message, fn, details) {
+    super(message);
+    this.status = status;
+    this.fn = fn;
+    this.details = details;
+  }
+};
+var ApiContractError = class extends Error {
+  constructor(fn, expected) {
+    super(`${fn} returned an invalid response: expected ${expected}. Please retry; if this persists, update Impractical Motion or contact support.`);
+    this.fn = fn;
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function bodyRecord(body) {
+  return isRecord(body) ? body : {};
+}
+function validateApiResponse(name, body, data) {
+  if (!isRecord(data)) throw new ApiContractError(name, "a JSON object");
+  const input = bodyRecord(body);
+  if (name === "workspace-bootstrap") {
+    const billing = data.billing;
+    if (typeof data.orgId !== "string" || typeof data.plan !== "string" || typeof data.hasAccess !== "boolean" || !isRecord(billing) || typeof billing.status !== "string") {
+      throw new ApiContractError(
+        name,
+        "an orgId, plan, hasAccess flag, and billing status"
+      );
+    }
+  }
+  if (name === "list-projects") {
+    const key = input.projectId ? "project" : "projects";
+    const value = data[key];
+    if (key === "projects" ? !Array.isArray(value) : !isRecord(value)) {
+      throw new ApiContractError(name, `an object with a ${key} ${key === "projects" ? "array" : "object"}`);
+    }
+  }
+  if (name === "prepare-generation") {
+    if (typeof data.projectId !== "string" || !Array.isArray(data.drafts) || data.drafts.length === 0 || !isRecord(data.drafts[0]) || typeof data.drafts[0].id !== "string") {
+      throw new ApiContractError(
+        name,
+        "a projectId and at least one draft with an id"
+      );
+    }
+  }
+  if (name === "get-draft" && (!isRecord(data.files) || typeof data.draftId !== "string")) {
+    throw new ApiContractError(name, "draft metadata and a files object");
+  }
+  if (name === "save-draft" && typeof data.revision !== "number") {
+    throw new ApiContractError(name, "a numeric revision");
+  }
+  if (name === "job-status" && !Array.isArray(data.jobs)) {
+    throw new ApiContractError(name, "an object with a jobs array");
+  }
+  if (name === "start-export" && typeof data.jobId !== "string") {
+    throw new ApiContractError(name, "an object with a jobId");
+  }
+  if (name === "brand-kits") {
+    const key = input.action === "list" ? "brands" : input.action === "get" ? "brand" : null;
+    if (key && (key === "brands" ? !Array.isArray(data[key]) : !isRecord(data[key]))) {
+      throw new ApiContractError(name, `an object with a ${key} ${key === "brands" ? "array" : "object"}`);
+    }
+  }
+  return data;
+}
+async function invoke(name, body = {}) {
+  const { apiKey, supabaseUrl } = requireConfig();
+  const receipt = admissionContext.getStore();
+  return invokeAt(supabaseUrl, name, body, apiKey, receipt);
+}
+async function invokeAt(supabaseUrl, name, body = {}, apiKey, admissionReceipt) {
+  const response = await fetch(`${supabaseUrl.replace(/\/$/, "")}/functions/v1/${name}`, {
+    method: "POST",
+    headers: {
+      ...apiKey ? { authorization: `Bearer ${apiKey}` } : {},
+      ...admissionReceipt ? { "x-impractical-admission": admissionReceipt } : {},
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (!response.ok) {
+    const details = isRecord(data) ? data : void 0;
+    const message = typeof details?.message === "string" && details.message || typeof details?.error === "string" && details.error || text || `${name} failed (${response.status})`;
+    throw new ApiError(response.status, message, name, details);
+  }
+  return validateApiResponse(name, body, data);
+}
+async function admitMcpCall(toolName, callId = randomUUID()) {
+  const { apiKey, supabaseUrl } = requireConfig();
+  return invokeAt(supabaseUrl, "mcp-admission", { callId, toolName }, apiKey);
+}
+function withAdmissionReceipt(receipt, task) {
+  return admissionContext.run(receipt, task);
+}
+async function withMeteredCall(toolName, task) {
+  const admission = await admitMcpCall(toolName);
+  return withAdmissionReceipt(admission.receipt, task);
+}
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function jobStatus(jobIds) {
+  const result = await invoke("job-status", { jobIds });
+  return result.jobs;
+}
+async function waitForJobs(jobIds, onTick, deadlineMs = 72e5) {
+  const deadline = Date.now() + deadlineMs;
+  const terminal = /* @__PURE__ */ new Set();
+  let latest = [];
+  while (terminal.size < jobIds.length) {
+    if (Date.now() >= deadline) throw new Error("Timed out waiting for jobs");
+    latest = await jobStatus(jobIds);
+    for (const row of latest) {
+      if (row.status === "completed" || row.status === "failed" || row.status === "canceled") {
+        terminal.add(row.id);
+      }
+    }
+    onTick(latest);
+    if (terminal.size < jobIds.length) await delay(2e3);
+  }
+  return latest;
+}
+function studioLink(appUrl, projectId, slug) {
+  const base = (appUrl ?? "http://localhost:5173").replace(/\/$/, "");
+  return `${base}/projects/${projectId}/studio${slug ? `?scene=${slug}` : ""}`;
+}
+
+// src/onboarding.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+var CLAUDE_MARKETPLACE = "Openpod/impractical-agent-plugins";
+var CLAUDE_PLUGIN = "impractical-motion@impractical";
+var CLAUDE_MARKETPLACE_NAME = "impractical";
+var AUTH_VERIFY_MIN_VERSION = "0.1.2";
+function parseSemver(value) {
+  const match = value.trim().match(
+    /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
+  );
+  if (!match) return void 0;
+  const prerelease = match[4] ? match[4].split(".").map((part) => /^(?:0|[1-9]\d*)$/.test(part) ? Number(part) : part) : [];
+  return {
+    main: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease
+  };
+}
+function compareSemver(left, right) {
+  const a = parseSemver(left);
+  const b = parseSemver(right);
+  if (!a || !b) return void 0;
+  for (let index = 0; index < a.main.length; index++) {
+    if (a.main[index] !== b.main[index]) return a.main[index] < b.main[index] ? -1 : 1;
+  }
+  if (!a.prerelease.length || !b.prerelease.length) {
+    if (a.prerelease.length === b.prerelease.length) return 0;
+    return a.prerelease.length ? -1 : 1;
+  }
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index++) {
+    const leftPart = a.prerelease[index];
+    const rightPart = b.prerelease[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      return leftPart === rightPart ? 0 : leftPart === void 0 ? -1 : 1;
+    }
+    if (leftPart === rightPart) continue;
+    if (typeof leftPart === "number" && typeof rightPart === "number") {
+      return leftPart < rightPart ? -1 : 1;
+    }
+    if (typeof leftPart === "number") return -1;
+    if (typeof rightPart === "number") return 1;
+    return leftPart < rightPart ? -1 : 1;
+  }
+  return 0;
+}
+function readJson(path) {
+  if (!existsSync2(path)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+var claudeConfigDir = () => process.env.CLAUDE_CONFIG_DIR?.trim() || join2(homedir2(), ".claude");
+function marketplaceRecord(configDir2) {
+  const value = readJson(join2(configDir2, "plugins", "known_marketplaces.json"));
+  return value?.impractical;
+}
+function installedPluginVersion(configDir2) {
+  const value = readJson(join2(configDir2, "plugins", "installed_plugins.json"));
+  const entries = value?.plugins?.[CLAUDE_PLUGIN];
+  if (!Array.isArray(entries)) return void 0;
+  const versions = entries.filter((entry) => entry?.scope === "user" && typeof entry.version === "string").map((entry) => entry.version);
+  return versions.reduce((highest, version) => {
+    if (!highest) return version;
+    const comparison = compareSemver(version, highest);
+    return comparison !== void 0 && comparison > 0 ? version : highest;
+  }, void 0);
+}
+function marketplacePluginVersion(configDir2) {
+  const record = marketplaceRecord(configDir2);
+  const location = typeof record?.installLocation === "string" ? record.installLocation : join2(configDir2, "plugins", "marketplaces", CLAUDE_MARKETPLACE_NAME);
+  const value = readJson(join2(location, ".claude-plugin", "marketplace.json"));
+  return value?.plugins?.find((plugin) => plugin.name === "impractical-motion")?.version;
+}
+function expectedMarketplace(record) {
+  const source = record?.source;
+  return source?.source === "github" && source.repo?.toLowerCase() === CLAUDE_MARKETPLACE.toLowerCase() && Object.keys(source).every((key) => key === "source" || key === "repo");
+}
+function marketplaceSourceLabel(record) {
+  if (record.source?.source === "directory") return "a local directory source";
+  return `a ${record.source?.source ?? "custom"} source`;
+}
+function commandResult(command, args) {
+  return spawnSync(command, args, { encoding: "utf8", windowsHide: true });
+}
+function requireCommand(command, label) {
+  const result = commandResult(command, ["--version"]);
+  if (result.error || result.status !== 0) {
+    throw new Error(`${label} is required before setup can continue.`);
+  }
+}
+function hasChrome() {
+  const macPaths = [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium"
+  ];
+  if (macPaths.some(existsSync2)) return true;
+  return ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"].some((command) => {
+    const result = spawnSync(command, ["--version"], { stdio: "ignore", windowsHide: true });
+    return !result.error && result.status === 0;
+  });
+}
+function verifyClaudePrerequisites() {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (!Number.isInteger(major) || major < 22) throw new Error("Node.js 22 or newer is required.");
+  requireCommand("claude", "Claude Code");
+  if (!hasChrome()) throw new Error("Google Chrome or Chromium is required to inspect video frames.");
+}
+function runClaude(args, log, tolerateAlreadyInstalled = false) {
+  const result = commandResult("claude", args);
+  const detail = `${result.stdout ?? ""}
+${result.stderr ?? ""}`.trim();
+  if (!result.error && result.status === 0) {
+    if (detail) log(detail);
+    const versionChange = detail.match(
+      /updated from\s+v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\s+to\s+v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/i
+    );
+    if (versionChange && (compareSemver(versionChange[2], versionChange[1]) ?? 0) < 0) {
+      log(
+        `WARNING: Claude reported a plugin downgrade ${versionChange[1]} \u2192 ${versionChange[2]}. The installed plugin may no longer include the timeout fix.`
+      );
+    }
+    return detail;
+  }
+  if (tolerateAlreadyInstalled && /already (?:added|exists|installed|configured)/i.test(detail)) {
+    if (detail) log(detail);
+    return detail;
+  }
+  throw new Error(`Claude plugin setup failed: ${detail || result.error?.message || "unknown error"}`);
+}
+function installClaudePlugin(log = () => {
+}) {
+  const configDir2 = claudeConfigDir();
+  const beforeVersion = installedPluginVersion(configDir2);
+  let record = marketplaceRecord(configDir2);
+  const preserveSource = Boolean(record && !expectedMarketplace(record));
+  if (preserveSource) {
+    log(
+      `Marketplace "${CLAUDE_MARKETPLACE_NAME}" already points at ${marketplaceSourceLabel(record)} \u2014 leaving it untouched. Run \`claude plugin marketplace add ${CLAUDE_MARKETPLACE}\` yourself to switch sources.`
+    );
+  } else if (!record) {
+    runClaude(["plugin", "marketplace", "add", CLAUDE_MARKETPLACE], log, true);
+    record = marketplaceRecord(configDir2);
+  }
+  if (!beforeVersion) {
+    runClaude(["plugin", "install", CLAUDE_PLUGIN, "--scope", "user"], log, true);
+  } else if (!preserveSource) {
+    const advertisedVersion = marketplacePluginVersion(configDir2);
+    const comparison = advertisedVersion ? compareSemver(beforeVersion, advertisedVersion) : void 0;
+    if (comparison === void 0) {
+      log(
+        `${CLAUDE_PLUGIN} ${beforeVersion} is installed, but the marketplace version could not be compared safely \u2014 left unchanged.`
+      );
+    } else if (comparison >= 0) {
+      log(
+        `${CLAUDE_PLUGIN} ${beforeVersion} already installed` + (comparison > 0 ? ` (newer than marketplace ${advertisedVersion})` : "") + " \u2014 left unchanged."
+      );
+    } else {
+      runClaude(["plugin", "marketplace", "update", CLAUDE_MARKETPLACE_NAME], log, true);
+      const refreshedVersion = marketplacePluginVersion(configDir2);
+      const currentVersion = installedPluginVersion(configDir2) ?? beforeVersion;
+      const refreshedComparison = refreshedVersion ? compareSemver(currentVersion, refreshedVersion) : void 0;
+      if (refreshedComparison !== void 0 && refreshedComparison < 0) {
+        runClaude(["plugin", "update", CLAUDE_PLUGIN], log, true);
+      } else {
+        log(
+          `${CLAUDE_PLUGIN} ${currentVersion} was not updated because the refreshed marketplace does not advertise a newer semantic version.`
+        );
+      }
+    }
+  }
+  const afterVersion = installedPluginVersion(configDir2);
+  const change = beforeVersion && afterVersion ? compareSemver(afterVersion, beforeVersion) : void 0;
+  if (change !== void 0 && change < 0) {
+    log(`WARNING: ${CLAUDE_PLUGIN} resolved to ${afterVersion}, below its prior ${beforeVersion}.`);
+  }
+  return {
+    beforeVersion,
+    afterVersion,
+    action: !afterVersion ? "unverified" : !beforeVersion ? "installed" : change !== void 0 && change > 0 ? "updated" : "unchanged"
+  };
+}
+function supportsAuthenticatedWhoami(version = PACKAGE_VERSION) {
+  return (compareSemver(version, AUTH_VERIFY_MIN_VERSION) ?? -1) >= 0;
+}
+function authenticatedWhoamiGuidance(version = PACKAGE_VERSION) {
+  if (!supportsAuthenticatedWhoami(version)) return [];
+  return [
+    `Verify the authenticated workspace with: npx --yes --package ${PACKAGE_NAME} impractical whoami`,
+    "A healthy result prints your org and plan; MCP \u201CConnected\u201D alone only proves startup."
+  ];
+}
+function pluginResultLine(result) {
+  if (!result.afterVersion) {
+    return `${CLAUDE_PLUGIN} setup completed, but Claude's resolved version could not be read back.`;
+  }
+  if (result.action === "installed") {
+    return `Installed ${CLAUDE_PLUGIN} ${result.afterVersion} for Claude Code (user scope).`;
+  }
+  if (result.action === "updated") {
+    return `Updated ${CLAUDE_PLUGIN} ${result.beforeVersion} \u2192 ${result.afterVersion} for Claude Code (user scope).`;
+  }
+  return `${CLAUDE_PLUGIN} already at ${result.afterVersion}; left unchanged.`;
+}
+var skillSourcePath = () => fileURLToPath(new URL("../assets/impractical/SKILL.md", import.meta.url));
+function installSkills(home = homedir2(), sourcePath = skillSourcePath()) {
+  const source = readFileSync2(sourcePath, "utf8");
+  const targets = [
+    {
+      harness: "Claude Code",
+      path: join2(home, ".claude", "skills", "impractical", "SKILL.md")
+    },
+    {
+      harness: "Codex",
+      path: join2(home, ".codex", "skills", "impractical", "SKILL.md")
+    }
+  ];
+  for (const target of targets) {
+    mkdirSync2(dirname(target.path), { recursive: true, mode: 448 });
+    writeFileSync2(target.path, source, { mode: 420 });
+  }
+  return targets;
+}
+function reconcileLegacySkills(home = homedir2(), sourcePath = skillSourcePath()) {
+  const source = readFileSync2(sourcePath, "utf8");
+  const targets = [
+    {
+      harness: "Claude Code",
+      path: join2(home, ".claude", "skills", "impractical", "SKILL.md")
+    },
+    {
+      harness: "Codex",
+      path: join2(home, ".codex", "skills", "impractical", "SKILL.md")
+    }
+  ];
+  const reconciled = [];
+  for (const target of targets) {
+    if (!existsSync2(target.path)) continue;
+    const previous = readFileSync2(target.path, "utf8");
+    if (previous === source) continue;
+    const backupPath = `${target.path}.pre-plugin`;
+    if (!existsSync2(backupPath)) writeFileSync2(backupPath, previous, { mode: 420 });
+    writeFileSync2(target.path, source, { mode: 420 });
+    reconciled.push({ ...target, backupPath });
+  }
+  return reconciled;
+}
+function browserCommand(url) {
+  if (process.platform === "darwin") return { command: "open", args: [url] };
+  if (process.platform === "win32") return { command: "cmd", args: ["/c", "start", "", url] };
+  return { command: "xdg-open", args: [url] };
+}
+function openBrowser(url) {
+  const launch = browserCommand(url);
+  const result = spawnSync(launch.command, launch.args, {
+    stdio: "ignore",
+    windowsHide: true
+  });
+  return !result.error && result.status === 0;
+}
+async function waitForApproval(supabaseUrl, authorization, log) {
+  const deadline = Date.parse(authorization.expiresAt);
+  const intervalMs = Math.max(1, authorization.intervalSeconds) * 1e3;
+  let announced = false;
+  while (Date.now() < deadline) {
+    const result = await invokeAt(supabaseUrl, "cli-device-auth", {
+      action: "poll",
+      deviceCode: authorization.deviceCode
+    });
+    if (result.status === "authorized") return result.apiKey;
+    if (!announced) {
+      log("Waiting for browser approval\u2026");
+      announced = true;
+    }
+    await delay(intervalMs);
+  }
+  throw new Error(`Authorization expired. Run \`${PACKAGE_COMMAND} setup --claude\` again.`);
+}
+async function setup(options) {
+  if (options.installClaudePlugin) verifyClaudePrerequisites();
+  const corruptConfigBackup = recoverCorruptConfig();
+  if (corruptConfigBackup) {
+    options.log(`Backed up invalid configuration to ${corruptConfigBackup}; starting clean.`);
+  }
+  const supabaseUrl = process.env.IMPRACTICAL_SUPABASE_URL?.trim() || PRODUCTION_SUPABASE_URL;
+  const appUrl = process.env.IMPRACTICAL_APP_URL?.trim() || PRODUCTION_APP_URL;
+  const existing = loadConfig();
+  let apiKey = existing.supabaseUrl === supabaseUrl ? existing.apiKey : void 0;
+  let verified;
+  if (apiKey) {
+    try {
+      verified = await invokeAt(supabaseUrl, "workspace-bootstrap", {}, apiKey);
+      options.log("Existing connection verified; browser authorization is not needed.");
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 401) throw error;
+      apiKey = void 0;
+    }
+  }
+  if (!apiKey) {
+    const authorization = await invokeAt(supabaseUrl, "cli-device-auth", {
+      action: "start"
+    });
+    options.log("");
+    options.log("Connect Impractical Motion");
+    options.log(`Code: ${authorization.userCode}`);
+    options.log(`Open: ${authorization.verificationUri}`);
+    options.log("");
+    if (options.openBrowser) {
+      const opened = openBrowser(authorization.verificationUri);
+      options.log(opened ? "Opened your browser." : "Could not open a browser automatically; use the link above.");
+    }
+    try {
+      apiKey = await waitForApproval(supabaseUrl, authorization, options.log);
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 410) {
+        throw new Error(`Authorization expired. Run \`${PACKAGE_COMMAND} setup --claude\` again.`);
+      }
+      throw error;
+    }
+    verified = await invokeAt(supabaseUrl, "workspace-bootstrap", {}, apiKey);
+    saveConfig({ apiKey, supabaseUrl, appUrl });
+  }
+  const claudePlugin = options.installClaudePlugin ? installClaudePlugin(options.log) : void 0;
+  const installed = options.installAgentSkills ? installSkills() : [];
+  const reconciled = reconcileLegacySkills();
+  options.log("");
+  options.log("Connected.");
+  for (const skill of installed) {
+    options.log(`Installed /impractical for ${skill.harness}.`);
+  }
+  for (const skill of reconciled) {
+    options.log(`Refreshed legacy /impractical for ${skill.harness}; previous copy preserved at ${skill.backupPath}.`);
+  }
+  if (claudePlugin) options.log(pluginResultLine(claudePlugin));
+  options.log(`Workspace: ${verified.orgId}${verified.plan ? ` \xB7 ${verified.plan}` : ""}`);
+  options.log("");
+  options.log("Run /reload-plugins, then type continue.");
+  if (options.installClaudePlugin) {
+    for (const line of authenticatedWhoamiGuidance()) options.log(line);
+  }
+  return { installed, appUrl, supabaseUrl };
+}
+
+export {
+  __commonJS,
+  __export,
+  __toESM,
+  PRODUCTION_APP_URL,
+  PRODUCTION_SUPABASE_URL,
+  PACKAGE_VERSION,
+  loadConfig,
+  saveConfig,
+  requireConfig,
+  ApiError,
+  validateApiResponse,
+  invoke,
+  invokeAt,
+  admitMcpCall,
+  withAdmissionReceipt,
+  withMeteredCall,
+  jobStatus,
+  waitForJobs,
+  studioLink,
+  openBrowser,
+  setup
+};