artbot 0.1.0

package/README.md

@@ -0,0 +1,32 @@
+# artbot
+
+Command-line client for ArtBot market research runs.
+
+## Install
+
+```bash
+npm install -g artbot
+```
+
+## Usage
+
+The CLI talks to an ArtBot API server. By default it uses `http://localhost:4000`.
+
+```bash
+artbot runs list
+artbot research artist --artist "Burhan Dogancay" --wait
+artbot runs show --run-id <id>
+```
+
+To point the CLI at a different backend:
+
+```bash
+export API_BASE_URL=https://your-artbot-api.example.com
+artbot runs list
+```
+
+For local development in this monorepo, start the API and worker first:
+
+```bash
+pnpm run start:artbot
+```

package/bin/artbot.cjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+(async () => {
+  try {
+    const { runCli } = await import("../dist/index.js");
+    process.exitCode = await runCli(process.argv);
+  } catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+  }
+})();

package/dist/chunks/chunk-KKAF45ZB.js

@@ -0,0 +1,667 @@
+// src/lib/file-system.ts
+import fs from "node:fs";
+function pathExists(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statFile(filePath) {
+  try {
+    return fs.statSync(filePath);
+  } catch {
+    return null;
+  }
+}
+
+// src/setup/env.ts
+import fs2 from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { config as loadDotenv } from "dotenv";
+var SETUP_PROFILE_BLUEPRINTS = [
+  {
+    id: "artsy-auth",
+    mode: "authorized",
+    sourceName: "Artsy",
+    sourcePatterns: ["artsy"]
+  },
+  {
+    id: "mutualart-auth",
+    mode: "authorized",
+    sourceName: "MutualArt",
+    sourcePatterns: ["mutualart"]
+  },
+  {
+    id: "sanatfiyat-license",
+    mode: "licensed",
+    sourceName: "Sanatfiyat",
+    sourcePatterns: ["sanatfiyat"]
+  },
+  {
+    id: "askart-license",
+    mode: "licensed",
+    sourceName: "askART",
+    sourcePatterns: ["askart"]
+  }
+];
+var CLI_MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
+var loadedEnvPath = null;
+function formatEnvValue(value) {
+  if (/^[A-Za-z0-9_./,:-]+$/.test(value)) {
+    return value;
+  }
+  if (!value.includes("'") && !value.includes("\n") && !value.includes("\r")) {
+    return `'${value}'`;
+  }
+  return JSON.stringify(value);
+}
+function isWorkspaceRoot(directory) {
+  return fs2.existsSync(path.join(directory, "pnpm-workspace.yaml")) || fs2.existsSync(path.join(directory, "turbo.json"));
+}
+function coerceSearchDirectory(candidate) {
+  const resolved = path.resolve(candidate);
+  try {
+    return fs2.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+  } catch {
+    return path.extname(resolved) ? path.dirname(resolved) : resolved;
+  }
+}
+function findWorkspaceRoot(candidate) {
+  let current = coerceSearchDirectory(candidate);
+  while (true) {
+    if (isWorkspaceRoot(current)) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function detectWorkspaceRoot(cwd = process.cwd()) {
+  const candidates = [
+    process.env.INIT_CWD,
+    cwd,
+    process.env.ARTBOT_ROOT,
+    process.env.RUNS_ROOT,
+    process.env.DATABASE_PATH,
+    CLI_MODULE_DIR
+  ].filter((candidate) => Boolean(candidate && candidate.trim().length > 0));
+  for (const candidate of candidates) {
+    const workspaceRoot = findWorkspaceRoot(candidate);
+    if (workspaceRoot) {
+      return workspaceRoot;
+    }
+  }
+  return null;
+}
+function resolveWorkspaceRoot(cwd = process.cwd()) {
+  return detectWorkspaceRoot(cwd) ?? path.resolve(cwd);
+}
+function hasLocalBackendWorkspace(cwd = process.cwd()) {
+  const workspaceRoot = detectWorkspaceRoot(cwd);
+  if (!workspaceRoot) {
+    return false;
+  }
+  return fs2.existsSync(path.join(workspaceRoot, "apps", "api", "package.json")) && fs2.existsSync(path.join(workspaceRoot, "apps", "worker", "package.json"));
+}
+function resolveEnvFilePath(cwd = process.cwd()) {
+  return path.resolve(resolveWorkspaceRoot(cwd), ".env");
+}
+function loadWorkspaceEnv(cwd = process.cwd()) {
+  const envPath = resolveEnvFilePath(cwd);
+  if (loadedEnvPath === envPath) {
+    return envPath;
+  }
+  loadDotenv({ path: envPath, override: false });
+  loadedEnvPath = envPath;
+  return envPath;
+}
+function parseBooleanEnv(value, fallback) {
+  if (value == null || value.trim() === "") return fallback;
+  return value.trim().toLowerCase() === "true";
+}
+function readEnvFile(envPath) {
+  try {
+    return fs2.readFileSync(envPath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function upsertEnvFile(envPath, updates) {
+  const existing = readEnvFile(envPath);
+  const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
+  const consumed = /* @__PURE__ */ new Set();
+  const nextLines = lines.map((line) => {
+    const match = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+    if (!match) {
+      return line;
+    }
+    const key = match[1];
+    if (!(key in updates)) {
+      return line;
+    }
+    consumed.add(key);
+    return `${key}=${formatEnvValue(updates[key])}`;
+  });
+  for (const [key, value] of Object.entries(updates)) {
+    if (consumed.has(key)) continue;
+    nextLines.push(`${key}=${formatEnvValue(value)}`);
+  }
+  fs2.writeFileSync(envPath, `${nextLines.filter(Boolean).join("\n")}
+`, "utf-8");
+}
+function buildDefaultAuthProfiles(options = {}) {
+  const cwd = resolveWorkspaceRoot(options.cwd ?? process.cwd());
+  const enableOptionalProbes = options.enableOptionalProbes ?? false;
+  const enableLicensedIntegrations = options.enableLicensedIntegrations ?? false;
+  return SETUP_PROFILE_BLUEPRINTS.filter((profile) => {
+    if (profile.id === "artsy-auth" || profile.id === "mutualart-auth") {
+      return enableOptionalProbes;
+    }
+    return enableLicensedIntegrations;
+  }).map((profile) => ({
+    id: profile.id,
+    mode: profile.mode,
+    sourcePatterns: profile.sourcePatterns,
+    storageStatePath: path.resolve(cwd, "playwright", ".auth", `${profile.id}.json`)
+  }));
+}
+function buildSetupEnvUpdates(values) {
+  return {
+    LLM_BASE_URL: values.llmBaseUrl,
+    API_BASE_URL: values.apiBaseUrl,
+    ENABLE_OPTIONAL_PROBE_ADAPTERS: String(values.enableOptionalProbes),
+    ENABLE_LICENSED_INTEGRATIONS: String(values.enableLicensedIntegrations),
+    DEFAULT_LICENSED_INTEGRATIONS: values.defaultLicensedIntegrations.join(","),
+    DEFAULT_AUTH_PROFILE: "",
+    AUTH_PROFILES_JSON: JSON.stringify(values.authProfiles)
+  };
+}
+function defaultSourceUrlForProfile(profileId) {
+  switch (profileId) {
+    case "artsy-auth":
+      return "https://www.artsy.net";
+    case "mutualart-auth":
+      return "https://www.mutualart.com";
+    case "sanatfiyat-license":
+      return "https://www.sanatfiyat.com";
+    case "askart-license":
+      return "https://www.askart.com";
+    default:
+      return "https://example.com";
+  }
+}
+
+// src/setup/auth.ts
+import path2 from "node:path";
+function normalizeSourcePattern(value) {
+  return value.trim().toLowerCase();
+}
+function buildAuthProfilesParseCandidates(rawValue) {
+  const trimmed = rawValue.trim();
+  const candidates = [trimmed];
+  const pushCandidate = (candidate) => {
+    if (candidate.length > 0 && !candidates.includes(candidate)) {
+      candidates.push(candidate);
+    }
+  };
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    pushCandidate(trimmed.slice(1, -1));
+  }
+  for (const candidate of [...candidates]) {
+    const repaired = candidate.replace(/\\"/g, '"');
+    if (repaired !== candidate) {
+      pushCandidate(repaired);
+    }
+  }
+  return candidates;
+}
+function parseAuthProfilesJson(rawValue) {
+  if (!rawValue || rawValue.trim().length === 0) {
+    return { profiles: [], error: null };
+  }
+  try {
+    let parsed;
+    let parsedSuccessfully = false;
+    let lastError;
+    for (const candidate of buildAuthProfilesParseCandidates(rawValue)) {
+      try {
+        parsed = candidate;
+        for (let depth = 0; depth < 3 && typeof parsed === "string"; depth += 1) {
+          parsed = JSON.parse(parsed);
+        }
+        parsedSuccessfully = true;
+        break;
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (!parsedSuccessfully) {
+      throw lastError ?? new Error("AUTH_PROFILES_JSON is not valid JSON.");
+    }
+    if (!Array.isArray(parsed)) {
+      return {
+        profiles: [],
+        error: {
+          message: "AUTH_PROFILES_JSON must be a JSON array.",
+          rawValue
+        }
+      };
+    }
+    const profiles = [];
+    for (const [index, entry] of parsed.entries()) {
+      if (!entry || typeof entry !== "object") {
+        return {
+          profiles: [],
+          error: {
+            message: `AUTH_PROFILES_JSON entry ${index} is not an object.`,
+            rawValue
+          }
+        };
+      }
+      const candidate = entry;
+      if (typeof candidate.id !== "string" || candidate.id.trim().length === 0) {
+        return {
+          profiles: [],
+          error: {
+            message: `AUTH_PROFILES_JSON entry ${index} is missing a valid id.`,
+            rawValue
+          }
+        };
+      }
+      if (candidate.mode !== "authorized" && candidate.mode !== "licensed") {
+        return {
+          profiles: [],
+          error: {
+            message: `AUTH_PROFILES_JSON entry ${index} has invalid mode "${String(candidate.mode)}".`,
+            rawValue
+          }
+        };
+      }
+      if (!Array.isArray(candidate.sourcePatterns) || candidate.sourcePatterns.some((pattern) => typeof pattern !== "string")) {
+        return {
+          profiles: [],
+          error: {
+            message: `AUTH_PROFILES_JSON entry ${index} must define sourcePatterns as an array of strings.`,
+            rawValue
+          }
+        };
+      }
+      profiles.push({
+        id: candidate.id.trim(),
+        mode: candidate.mode,
+        sourcePatterns: candidate.sourcePatterns.map((pattern) => pattern.trim()).filter(Boolean),
+        cookieFile: candidate.cookieFile,
+        usernameEnv: candidate.usernameEnv,
+        passwordEnv: candidate.passwordEnv,
+        apiKeyEnv: candidate.apiKeyEnv,
+        storageStatePath: candidate.storageStatePath,
+        sessionTtlMinutes: candidate.sessionTtlMinutes
+      });
+    }
+    return { profiles, error: null };
+  } catch (error) {
+    return {
+      profiles: [],
+      error: {
+        message: "AUTH_PROFILES_JSON is not valid JSON.",
+        details: error instanceof Error ? error.message : String(error),
+        rawValue
+      }
+    };
+  }
+}
+function resolveAuthProfilesFromEnv(env = process.env) {
+  if (env === process.env) {
+    loadWorkspaceEnv();
+  }
+  return parseAuthProfilesJson(env.AUTH_PROFILES_JSON);
+}
+function resolveStorageStatePath(profile, cwd = process.cwd()) {
+  return profile.storageStatePath ? path2.resolve(cwd, profile.storageStatePath) : path2.resolve(cwd, "playwright", ".auth", `${profile.id}.json`);
+}
+function inspectSessionState(profile, cwd = process.cwd(), now = /* @__PURE__ */ new Date()) {
+  const storageStatePath = resolveStorageStatePath(profile, cwd);
+  const exists = pathExists(storageStatePath);
+  const stat = exists ? statFile(storageStatePath) : null;
+  const lastModifiedAtIso = stat?.mtime.toISOString() ?? null;
+  const ttlMinutes = profile.sessionTtlMinutes ?? 6 * 60;
+  let expired = true;
+  if (exists && stat) {
+    expired = now.getTime() - stat.mtime.getTime() > ttlMinutes * 60 * 1e3;
+  }
+  return {
+    profileId: profile.id,
+    storageStatePath,
+    exists,
+    lastModifiedAtIso,
+    expired
+  };
+}
+function inspectSessionStates(profiles, cwd = process.cwd(), now = /* @__PURE__ */ new Date()) {
+  return profiles.map((profile) => inspectSessionState(profile, cwd, now));
+}
+function findAuthRelevantProfiles(profiles, sourceNames) {
+  const loweredSources = sourceNames.map(normalizeSourcePattern);
+  return profiles.map((profile) => {
+    const matchedSources = loweredSources.filter(
+      (source) => profile.sourcePatterns.some((pattern) => {
+        try {
+          return new RegExp(pattern, "i").test(source);
+        } catch {
+          return source.includes(normalizeSourcePattern(pattern));
+        }
+      })
+    );
+    return { profile, matchedSources };
+  }).filter((entry) => entry.matchedSources.length > 0);
+}
+function buildAuthCaptureCommand(profile, sourceUrl, storageStatePath = resolveStorageStatePath(profile)) {
+  const command = `artbot auth capture ${profile.id}`;
+  return {
+    profileId: profile.id,
+    sourceUrl,
+    storageStatePath,
+    command
+  };
+}
+
+// src/setup/workflow.ts
+import * as clack from "@clack/prompts";
+import picocolors from "picocolors";
+
+// src/setup/backend.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { spawn } from "node:child_process";
+function resolveBackendStartMetadata(cwd = process.cwd(), apiBaseUrl = "http://localhost:4000") {
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  return {
+    api: {
+      service: "api",
+      command: "pnpm --filter @artbot/api dev",
+      cwd: workspaceRoot,
+      displayName: "ArtBot API"
+    },
+    worker: {
+      service: "worker",
+      command: "pnpm --filter @artbot/worker dev",
+      cwd: workspaceRoot,
+      displayName: "ArtBot worker"
+    },
+    apiHealthPath: `${apiBaseUrl.replace(/\/$/, "")}/health`,
+    recommendedEntryCommand: "pnpm run start:artbot"
+  };
+}
+function spawnDetachedProcess(command, cwd, logPath) {
+  const logFd = fs3.openSync(logPath, "a");
+  const child = spawn(command, {
+    cwd,
+    shell: true,
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  child.unref();
+  fs3.closeSync(logFd);
+  return child.pid ?? -1;
+}
+function startLocalBackendServices(cwd = process.cwd()) {
+  if (!hasLocalBackendWorkspace(cwd)) {
+    throw new Error("Local backend auto-start is only available from an ArtBot workspace checkout.");
+  }
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const logDir = path3.resolve(workspaceRoot, ".artbot-logs");
+  fs3.mkdirSync(logDir, { recursive: true });
+  const apiLogPath = path3.join(logDir, `api-${stamp}.log`);
+  const workerLogPath = path3.join(logDir, `worker-${stamp}.log`);
+  const metadata = resolveBackendStartMetadata(workspaceRoot);
+  const apiPid = spawnDetachedProcess(metadata.api.command, workspaceRoot, apiLogPath);
+  const workerPid = spawnDetachedProcess(metadata.worker.command, workspaceRoot, workerLogPath);
+  return {
+    logDir,
+    apiLogPath,
+    workerLogPath,
+    apiPid,
+    workerPid
+  };
+}
+
+// src/setup/health.ts
+async function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function checkLlmHealth(baseUrl, apiKey = "", timeoutMs = 1500) {
+  const headers = {};
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+  }
+  try {
+    const response = await fetchWithTimeout(`${baseUrl.replace(/\/$/, "")}/models`, { headers }, timeoutMs);
+    if (!response.ok) {
+      return {
+        ok: false,
+        baseUrl,
+        statusCode: response.status,
+        reason: `HTTP ${response.status}`
+      };
+    }
+    const payload = await response.json();
+    return {
+      ok: true,
+      baseUrl,
+      modelId: payload.data?.[0]?.id
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      baseUrl,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function checkApiHealth(apiBaseUrl, apiKey = "", timeoutMs = 1500) {
+  const headers = {};
+  if (apiKey) {
+    headers["x-api-key"] = apiKey;
+  }
+  try {
+    const response = await fetchWithTimeout(`${apiBaseUrl.replace(/\/$/, "")}/health`, { headers }, timeoutMs);
+    if (!response.ok) {
+      return {
+        ok: false,
+        apiBaseUrl,
+        statusCode: response.status,
+        reason: `HTTP ${response.status}`
+      };
+    }
+    return { ok: true, apiBaseUrl };
+  } catch (error) {
+    return {
+      ok: false,
+      apiBaseUrl,
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/setup/workflow.ts
+function createIssue(severity, code, message, detail) {
+  return { severity, code, message, detail };
+}
+async function assessLocalSetup(env = process.env, cwd = process.cwd()) {
+  if (env === process.env) {
+    loadWorkspaceEnv(cwd);
+  }
+  const workspaceRoot = detectWorkspaceRoot(cwd);
+  const resolvedCwd = resolveWorkspaceRoot(cwd);
+  const envPath = resolveEnvFilePath(resolvedCwd);
+  const localBackendAvailable = hasLocalBackendWorkspace(cwd);
+  const llmBaseUrl = env.LLM_BASE_URL?.trim() || "http://127.0.0.1:1234/v1";
+  const apiBaseUrl = env.API_BASE_URL?.trim() || "http://localhost:4000";
+  const llmHealth = await checkLlmHealth(llmBaseUrl, env.LLM_API_KEY ?? env.OPENAI_API_KEY ?? "lm-studio");
+  const apiHealth = await checkApiHealth(apiBaseUrl, env.ARTBOT_API_KEY);
+  const parsedProfiles = parseAuthProfilesJson(env.AUTH_PROFILES_JSON);
+  const profiles = parsedProfiles.profiles;
+  const enableOptionalProbes = parseBooleanEnv(env.ENABLE_OPTIONAL_PROBE_ADAPTERS, false);
+  const enableLicensedIntegrations = parseBooleanEnv(env.ENABLE_LICENSED_INTEGRATIONS, false);
+  const enabledSourceNames = [
+    ...enableOptionalProbes ? ["Artsy", "MutualArt", "askART"] : [],
+    ...enableLicensedIntegrations ? ["Sanatfiyat"] : []
+  ];
+  const relevantProfiles = findAuthRelevantProfiles(profiles, enabledSourceNames);
+  const sessionStates = inspectSessionStates(relevantProfiles.map((entry) => entry.profile), resolvedCwd);
+  const issues = [];
+  if (!llmHealth.ok) {
+    issues.push(createIssue("error", "llm_unreachable", "LM Studio is not reachable.", llmHealth.reason));
+  }
+  if (!apiHealth.ok) {
+    issues.push(createIssue("warning", "api_unreachable", "ArtBot API is not reachable.", apiHealth.reason));
+    if (!localBackendAvailable) {
+      issues.push(
+        createIssue(
+          "warning",
+          "local_backend_unavailable",
+          "Local backend auto-start is unavailable outside the ArtBot repo.",
+          "Set API_BASE_URL to a running ArtBot API."
+        )
+      );
+    }
+  }
+  if (parsedProfiles.error) {
+    issues.push(createIssue("error", "auth_profiles_invalid", parsedProfiles.error.message, parsedProfiles.error.details));
+  }
+  if (enabledSourceNames.length > 0 && profiles.length === 0) {
+    issues.push(createIssue("warning", "auth_profiles_missing", "Auth-capable sources are enabled but no auth profiles are configured."));
+  }
+  for (const session of sessionStates) {
+    if (!session.exists) {
+      issues.push(createIssue("warning", "auth_session_missing", `Missing browser session for ${session.profileId}.`, session.storageStatePath));
+      continue;
+    }
+    if (session.expired) {
+      issues.push(createIssue("warning", "auth_session_expired", `Saved browser session expired for ${session.profileId}.`, session.storageStatePath));
+    }
+  }
+  return {
+    cwd: resolvedCwd,
+    workspaceRoot,
+    envPath,
+    localBackendAvailable,
+    llmBaseUrl,
+    apiBaseUrl,
+    llmHealth,
+    apiHealth,
+    profiles,
+    authProfilesError: parsedProfiles.error,
+    relevantProfiles,
+    sessionStates,
+    issues
+  };
+}
+async function runSetupWizard(cwd = process.cwd()) {
+  const env = process.env;
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
+  const localBackendAvailable = hasLocalBackendWorkspace(cwd);
+  const llmBaseUrl = await clack.text({
+    message: "LM Studio base URL",
+    initialValue: env.LLM_BASE_URL?.trim() || "http://127.0.0.1:1234/v1",
+    validate(input) {
+      return input.trim().length === 0 ? "LM Studio URL is required." : void 0;
+    }
+  });
+  if (clack.isCancel(llmBaseUrl)) throw new Error("Setup cancelled.");
+  const apiBaseUrl = await clack.text({
+    message: "ArtBot API base URL",
+    initialValue: env.API_BASE_URL?.trim() || "http://localhost:4000",
+    validate(input) {
+      return input.trim().length === 0 ? "API URL is required." : void 0;
+    }
+  });
+  if (clack.isCancel(apiBaseUrl)) throw new Error("Setup cancelled.");
+  const enableOptionalProbes = await clack.confirm({
+    message: "Enable optional probe sources (Artsy, MutualArt, askART)?",
+    initialValue: parseBooleanEnv(env.ENABLE_OPTIONAL_PROBE_ADAPTERS, false)
+  });
+  if (clack.isCancel(enableOptionalProbes)) throw new Error("Setup cancelled.");
+  const enableLicensedIntegrations = await clack.confirm({
+    message: "Enable licensed integrations?",
+    initialValue: parseBooleanEnv(env.ENABLE_LICENSED_INTEGRATIONS, true)
+  });
+  if (clack.isCancel(enableLicensedIntegrations)) throw new Error("Setup cancelled.");
+  const defaultLicensedIntegrations = enableLicensedIntegrations ? ["Sanatfiyat"] : [];
+  const authProfiles = buildDefaultAuthProfiles({
+    cwd: workspaceRoot,
+    enableOptionalProbes,
+    enableLicensedIntegrations
+  });
+  const values = {
+    llmBaseUrl: llmBaseUrl.trim(),
+    apiBaseUrl: apiBaseUrl.trim(),
+    enableOptionalProbes,
+    enableLicensedIntegrations,
+    defaultLicensedIntegrations,
+    authProfiles
+  };
+  const envPath = resolveEnvFilePath(workspaceRoot);
+  upsertEnvFile(envPath, buildSetupEnvUpdates(values));
+  clack.log.success(`Updated ${picocolors.bold(envPath)}`);
+  let backendStart = null;
+  const apiHealth = await checkApiHealth(values.apiBaseUrl, process.env.ARTBOT_API_KEY);
+  if (!apiHealth.ok && localBackendAvailable) {
+    const shouldStartBackend = await clack.confirm({
+      message: "ArtBot API is offline. Start local API and worker now?",
+      initialValue: true
+    });
+    if (clack.isCancel(shouldStartBackend)) throw new Error("Setup cancelled.");
+    if (shouldStartBackend) {
+      backendStart = startLocalBackendServices(workspaceRoot);
+      clack.log.info(`Started local backend. API log: ${backendStart.apiLogPath}`);
+      clack.log.info(`Worker log: ${backendStart.workerLogPath}`);
+    }
+  } else if (!apiHealth.ok) {
+    clack.log.info("Local backend auto-start is only available inside the ArtBot repo.");
+    clack.log.info("Set API_BASE_URL to a running ArtBot API or start the services manually.");
+  }
+  const captureNow = authProfiles.length > 0 ? await clack.confirm({
+    message: "Capture browser login sessions now?",
+    initialValue: false
+  }) : false;
+  if (clack.isCancel(captureNow)) throw new Error("Setup cancelled.");
+  if (captureNow) {
+    for (const profile of authProfiles) {
+      const shouldCaptureProfile = await clack.confirm({
+        message: `Capture session for ${profile.id}?`,
+        initialValue: !profile.id.startsWith("artsy") && !profile.id.startsWith("askart")
+      });
+      if (clack.isCancel(shouldCaptureProfile)) throw new Error("Setup cancelled.");
+      if (!shouldCaptureProfile) continue;
+      const command = buildAuthCaptureCommand(profile, defaultSourceUrlForProfile(profile.id));
+      clack.log.message(`${picocolors.cyan("Auth capture")}: ${command.command}`);
+    }
+  }
+  const assessment = await assessLocalSetup(process.env, workspaceRoot);
+  return { assessment, backendStart };
+}
+
+export {
+  pathExists,
+  loadWorkspaceEnv,
+  defaultSourceUrlForProfile,
+  resolveAuthProfilesFromEnv,
+  buildAuthCaptureCommand,
+  assessLocalSetup,
+  runSetupWizard
+};
+//# sourceMappingURL=chunk-KKAF45ZB.js.map