@ekzs/cli 0.2.0 → 0.3.3

package/dist/commands/local-agent.js

@@ -1,83 +1,87 @@
 import { resolve } from "path";
-import { Agent, AgentBusyError, CursorAgentError } from "@cursor/sdk";
 import { executeAskTurn } from "../commands/ask.js";
 import { runDoctor } from "../commands/doctor.js";
 import { runScan } from "../commands/scan.js";
 import { inputPlaceholder, printHelp, printLangSwitch, printModeSwitch, printWelcome } from "../lib/banner.js";
 import { loadProjectEnv } from "../lib/env.js";
-import { resolveReplMetaCommand } from "../lib/commands-i18n.js";
+import { ensureAgentReady, offlineAgentHint, offlineModelLabel } from "../lib/onboarding.js";
+import { resolveReplMetaCommand, isProvidersMetaCommand } from "../lib/commands-i18n.js";
 import { buildAgentPrompt, buildBootstrapContext } from "../lib/context.js";
 import { resolveComposerModel } from "../lib/composer-model.js";
 import { parseLocale, uiStrings } from "../lib/locale.js";
 import { modeRequiresCursorAgent, parseMode } from "../lib/mode.js";
 import { loadPreferences, savePreferences } from "../lib/preferences.js";
+import { runByokAgentTurn, usesCursorSdk } from "../lib/providers/agent-runner.js";
+import { CursorSdkMissingError, loadCursorSdk } from "../lib/providers/cursor-sdk.js";
+import { disposeAgent, streamRun } from "../lib/providers/cursor-runner.js";
+import { resolveActiveCredentials, resolveCredentialsWithOverride, } from "../lib/providers/credentials.js";
+import { runProvidersInteractive, formatActiveProviderLabel } from "../lib/providers/ui.js";
 import { clearSession, getSessionByIndex, loadSession, persistSession, saveNamedSession, } from "../lib/session.js";
 import { fail, info, ok, warn } from "../lib/output.js";
-import { toolDone, toolError, toolRunning, turnDivider } from "../lib/theme.js";
+import { turnDivider } from "../lib/theme.js";
 import { askWithPlaceholder, formatInputPrompt } from "../lib/ui/prompt.js";
-function getApiKey(override, cwd) {
-    if (cwd)
-        loadProjectEnv(cwd);
-    else
-        loadProjectEnv(process.cwd());
-    const key = override ?? process.env.CURSOR_API_KEY?.trim();
-    if (!key) {
-        throw new Error("CURSOR_API_KEY required. Add it to .env.local or export it — https://cursor.com/dashboard/integrations");
-    }
-    return key;
-}
-async function disposeAgent(agent) {
-    const disposer = agent[Symbol.asyncDispose];
-    if (typeof disposer === "function")
-        await disposer.call(agent);
-    else
-        agent.close();
-}
-async function streamRun(agent, prompt, locale, opts) {
-    const t = uiStrings(locale);
-    const sendOptions = {
-        onDelta: ({ update }) => {
-            if (update.type === "text-delta" && update.text) {
-                process.stdout.write(update.text);
-            }
-        },
-        ...(opts?.force ? { local: { force: true } } : {}),
-    };
-    let run;
+async function prepareAgentSession(opts, prefs) {
     try {
-        run = await agent.send(prompt, sendOptions);
+        const ready = await ensureAgentReady({
+            locale: prefs.locale,
+            offlineFlag: opts.askOffline,
+            apiKey: opts.apiKey,
+        });
+        return { offline: ready.offline, creds: ready.creds };
     }
     catch (err) {
-        if (err instanceof AgentBusyError) {
-            warn(t.busyRun);
-            run = await agent.send(prompt, { ...sendOptions, local: { force: true } });
-        }
-        else {
-            throw err;
-        }
+        fail(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+        return null;
     }
-    for await (const event of run.stream()) {
-        if (event.type === "tool_call" && event.status === "running") {
-            process.stdout.write(toolRunning(event.name));
+}
+function resolveAgentCredentials(override, locale = "pt") {
+    return resolveCredentialsWithOverride(override, locale);
+}
+function resolveCursorModel(creds) {
+    return resolveComposerModel(process.env, creds.model);
+}
+function providerModelLabel(creds) {
+    if (usesCursorSdk(creds))
+        return resolveCursorModel(creds).label;
+    return `${creds.definition.name} · ${creds.model}`;
+}
+async function runAgentTurn(options) {
+    if (usesCursorSdk(options.creds)) {
+        if (!options.cursorAgent) {
+            fail(options.locale === "pt" ? "Sem agente Cursor activo." : "No active Cursor agent.");
+            return { cursorAgent: null, ok: false };
         }
-        if (event.type === "tool_call" && event.status === "completed") {
-            process.stdout.write(toolDone(event.name));
+        const ctx = await buildBootstrapContext(options.cwd);
+        const prompt = buildAgentPrompt(options.task, ctx, options.locale);
+        try {
+            await streamRun(options.cursorAgent, prompt, options.locale);
+            console.log("\n");
+            return { cursorAgent: options.cursorAgent, ok: true };
         }
-        if (event.type === "tool_call" && event.status === "error") {
-            process.stdout.write(toolError(event.name));
+        catch (err) {
+            if (err instanceof Error && err.name === "CursorAgentError") {
+                fail(err.message);
+                return { cursorAgent: options.cursorAgent, ok: false };
+            }
+            throw err;
         }
     }
-    const result = await run.wait();
-    if (result.status === "error") {
-        fail(`${t.agentFailed} (${result.id})`);
-        process.exitCode = 2;
-    }
-    return { status: result.status, result: result.result };
+    const okResult = await runByokAgentTurn({
+        cwd: options.cwd,
+        task: options.task,
+        creds: options.creds,
+        locale: options.locale,
+        mode: options.mode,
+    });
+    return { cursorAgent: options.cursorAgent, ok: okResult };
 }
-async function createOrResumeAgent(opts) {
+async function createOrResumeAgent(opts, locale = "pt") {
     const cwd = resolve(opts.cwd);
-    const apiKey = getApiKey(opts.apiKey, cwd);
-    const model = resolveComposerModel();
+    const creds = resolveAgentCredentials(opts.apiKey, locale);
+    const { Agent } = await loadCursorSdk(locale);
+    const apiKey = creds.apiKey;
+    const model = resolveCursorModel(creds);
     const usePlan = opts.mode === "plan" || Boolean(opts.plan);
     if (opts.fresh)
         clearSession(cwd);
@@ -100,9 +104,12 @@ async function createOrResumeAgent(opts) {
     });
     return { agent, resumed: false };
 }
-async function recreateAgentForMode(cwd, current, mode, apiKey) {
+async function recreateAgentForMode(cwd, current, mode, apiKey, locale = "pt") {
     if (!modeRequiresCursorAgent(mode))
         return null;
+    const creds = resolveAgentCredentials(apiKey, locale);
+    if (!usesCursorSdk(creds))
+        return null;
     if (current)
         await disposeAgent(current);
     const { agent } = await createOrResumeAgent({
@@ -111,12 +118,12 @@ async function recreateAgentForMode(cwd, current, mode, apiKey) {
         fresh: true,
         mode,
         apiKey,
-    });
+    }, locale);
     await persistAgent(cwd, agent);
     return agent;
 }
-async function persistAgent(cwd, agent) {
-    const model = resolveComposerModel();
+async function persistAgent(cwd, agent, creds) {
+    const model = creds ? resolveCursorModel(creds) : resolveComposerModel();
     persistSession(cwd, {
         agentId: agent.agentId,
         cwd: resolve(cwd),
@@ -180,37 +187,53 @@ function handleMetaCommand(line, locale, cwd, currentMode) {
     }
     return null;
 }
-async function resumeAgentInRepl(cwd, current, agentId, locale) {
+async function resumeAgentInRepl(cwd, current, agentId, locale, apiKeyOverride) {
     if (current)
         await disposeAgent(current);
-    const apiKey = getApiKey(undefined, cwd);
-    const model = resolveComposerModel();
+    const creds = resolveAgentCredentials(apiKeyOverride, locale);
+    if (!usesCursorSdk(creds)) {
+        throw new Error(locale === "pt"
+            ? "Retomar sessão só com provider Cursor."
+            : locale === "zh"
+                ? "恢复会话仅适用于 Cursor provider。"
+                : "Resume session is Cursor-only.");
+    }
+    const { Agent } = await loadCursorSdk(locale);
+    const model = resolveCursorModel(creds);
     const agent = await Agent.resume(agentId, {
-        apiKey,
+        apiKey: creds.apiKey,
         model: { id: model.id, params: model.params },
         local: { cwd: resolve(cwd), settingSources: ["project"] },
     });
-    await persistAgent(cwd, agent);
+    await persistAgent(cwd, agent, creds);
     ok(locale === "pt" ? "Sessão retomada." : "Session resumed.");
     return agent;
 }
 export async function runLocalAgent(opts) {
     const cwd = resolve(opts.cwd);
     loadProjectEnv(cwd);
-    const model = resolveComposerModel();
     const prefs = loadPreferences(cwd, opts.locale, opts.mode, opts.plan);
     const mode = prefs.mode;
+    const session = await prepareAgentSession(opts, prefs);
+    if (!session)
+        return;
+    const { offline, creds: sessionCreds } = session;
+    const askOffline = offline || Boolean(opts.askOffline);
+    const providerLabel = askOffline
+        ? offlineModelLabel(prefs.locale)
+        : sessionCreds
+            ? formatActiveProviderLabel(prefs.locale)
+            : formatActiveProviderLabel(prefs.locale);
     if (mode === "ask") {
-        printWelcome({ cwd, locale: prefs.locale, mode: "ask" });
+        printWelcome({ cwd, locale: prefs.locale, mode: "ask", model: providerLabel });
         if (opts.task.trim()) {
             info(`${uiStrings(prefs.locale).workingOn}: ${opts.task.slice(0, 120)}${opts.task.length > 120 ? "…" : ""}\n`);
             await executeAskTurn({
                 cwd,
                 question: opts.task.trim(),
-                apiKey: opts.askApiKey,
-                apiUrl: opts.askApiUrl,
-                offline: opts.askOffline,
+                offline: askOffline,
                 quiet: true,
+                locale: prefs.locale,
             });
             console.log("");
         }
@@ -221,44 +244,88 @@ export async function runLocalAgent(opts) {
                 locale: prefs.locale,
                 mode: "ask",
                 apiKey: opts.apiKey,
-                askApiKey: opts.askApiKey,
-                askApiUrl: opts.askApiUrl,
-                askOffline: opts.askOffline,
+                askOffline,
+                creds: sessionCreds,
+                offline: askOffline,
+            });
+        }
+        return;
+    }
+    if (askOffline) {
+        printWelcome({ cwd, locale: prefs.locale, mode, model: providerLabel });
+        savePreferences(cwd, { mode });
+        if (opts.task.trim()) {
+            info(`${uiStrings(prefs.locale).workingOn}: ${opts.task.slice(0, 120)}${opts.task.length > 120 ? "…" : ""}\n`);
+            warn(offlineAgentHint(prefs.locale));
+        }
+        if (opts.interactive !== false) {
+            await runRepl({
+                agent: null,
+                cwd,
+                locale: prefs.locale,
+                mode,
+                apiKey: opts.apiKey,
+                askOffline: true,
+                creds: null,
+                offline: true,
             });
         }
         return;
     }
-    let agent;
+    if (!sessionCreds) {
+        fail(offlineAgentHint(prefs.locale));
+        process.exitCode = 1;
+        return;
+    }
+    let agent = null;
     let resumed = false;
+    const creds = sessionCreds;
     try {
-        ({ agent, resumed } = await createOrResumeAgent({ ...opts, mode }));
+        if (usesCursorSdk(creds)) {
+            ({ agent, resumed } = await createOrResumeAgent({ ...opts, mode }, prefs.locale));
+        }
     }
     catch (err) {
-        if (err instanceof CursorAgentError) {
+        if (err instanceof CursorSdkMissingError) {
+            fail(err.message);
+            process.exitCode = 1;
+            return;
+        }
+        if (err instanceof Error && err.name === "CursorAgentError") {
             fail(`Agent startup failed: ${err.message}`);
             process.exitCode = 1;
             return;
         }
-        throw err;
+        fail(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+        return;
     }
     printWelcome({
         cwd,
-        model: model.label,
+        model: providerModelLabel(creds),
         locale: prefs.locale,
         mode,
         resumed,
-        agentId: agent.agentId,
+        agentId: agent?.agentId,
     });
-    await persistAgent(cwd, agent);
+    if (agent)
+        await persistAgent(cwd, agent, creds);
     savePreferences(cwd, { mode });
-    const bootstrap = await buildBootstrapContext(cwd);
-    const prompt = buildAgentPrompt(opts.task, bootstrap, prefs.locale);
     const t = uiStrings(prefs.locale);
     try {
         info(`${t.workingOn}: ${opts.task.slice(0, 120)}${opts.task.length > 120 ? "…" : ""}\n`);
-        const outcome = await streamRun(agent, prompt, prefs.locale);
-        console.log("\n");
-        ok(`${t.done} (${outcome.status})`);
+        const outcome = await runAgentTurn({
+            cwd,
+            task: opts.task,
+            creds,
+            locale: prefs.locale,
+            mode,
+            cursorAgent: agent,
+        });
+        if (outcome.ok)
+            ok(t.done);
+        if (outcome.cursorAgent)
+            agent = outcome.cursorAgent;
         if (opts.interactive !== false) {
             await runRepl({
                 agent,
@@ -266,9 +333,9 @@ export async function runLocalAgent(opts) {
                 locale: prefs.locale,
                 mode,
                 apiKey: opts.apiKey,
-                askApiKey: opts.askApiKey,
-                askApiUrl: opts.askApiUrl,
-                askOffline: opts.askOffline,
+                askOffline,
+                creds,
+                offline: false,
             });
         }
         else {
@@ -276,51 +343,90 @@ export async function runLocalAgent(opts) {
         }
     }
     finally {
-        await disposeAgent(agent);
+        if (agent)
+            await disposeAgent(agent);
     }
 }
 export async function runInteractiveAgent(opts) {
     const cwd = resolve(opts.cwd);
     loadProjectEnv(cwd);
-    const model = resolveComposerModel();
     const prefs = loadPreferences(cwd, opts.locale, opts.mode, opts.plan);
     const mode = prefs.mode;
+    const session = await prepareAgentSession({ ...opts, task: "" }, prefs);
+    if (!session)
+        return;
+    const { offline, creds: sessionCreds } = session;
+    const askOffline = offline || Boolean(opts.askOffline);
+    const providerLabel = askOffline
+        ? offlineModelLabel(prefs.locale)
+        : formatActiveProviderLabel(prefs.locale);
     if (mode === "ask") {
-        printWelcome({ cwd, locale: prefs.locale, mode: "ask" });
+        printWelcome({ cwd, locale: prefs.locale, mode: "ask", model: providerLabel });
         await runRepl({
             agent: null,
             cwd,
             locale: prefs.locale,
             mode: "ask",
             apiKey: opts.apiKey,
-            askApiKey: opts.askApiKey,
-            askApiUrl: opts.askApiUrl,
-            askOffline: opts.askOffline,
+            askOffline,
+            creds: sessionCreds,
+            offline: askOffline,
         });
         return;
     }
-    let agent;
+    if (askOffline) {
+        printWelcome({ cwd, locale: prefs.locale, mode, model: providerLabel });
+        savePreferences(cwd, { mode });
+        await runRepl({
+            agent: null,
+            cwd,
+            locale: prefs.locale,
+            mode,
+            apiKey: opts.apiKey,
+            askOffline: true,
+            creds: null,
+            offline: true,
+        });
+        return;
+    }
+    if (!sessionCreds) {
+        fail(offlineAgentHint(prefs.locale));
+        process.exitCode = 1;
+        return;
+    }
+    let agent = null;
     let resumed = false;
+    const creds = sessionCreds;
     try {
-        ({ agent, resumed } = await createOrResumeAgent({ ...opts, task: "", mode }));
+        if (usesCursorSdk(creds)) {
+            ({ agent, resumed } = await createOrResumeAgent({ ...opts, task: "", mode }, prefs.locale));
+        }
     }
     catch (err) {
-        if (err instanceof CursorAgentError) {
+        if (err instanceof CursorSdkMissingError) {
+            fail(err.message);
+            process.exitCode = 1;
+            return;
+        }
+        if (err instanceof Error && err.name === "CursorAgentError") {
             fail(`Agent startup failed: ${err.message}`);
             process.exitCode = 1;
             return;
         }
-        throw err;
+        fail(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+        return;
     }
     printWelcome({
         cwd,
-        model: model.label,
+        model: providerModelLabel(creds),
         locale: prefs.locale,
         mode,
         resumed,
-        agentId: agent.agentId,
+        agentId: agent?.agentId,
     });
-    await persistAgent(cwd, agent);
+    if (agent)
+        await persistAgent(cwd, agent, creds);
     savePreferences(cwd, { mode });
     try {
         await runRepl({
@@ -329,21 +435,47 @@ export async function runInteractiveAgent(opts) {
             locale: prefs.locale,
             mode,
             apiKey: opts.apiKey,
-            askApiKey: opts.askApiKey,
-            askApiUrl: opts.askApiUrl,
-            askOffline: opts.askOffline,
+            askOffline,
+            creds,
+            offline: false,
         });
     }
     finally {
-        await disposeAgent(agent);
+        if (agent)
+            await disposeAgent(agent);
     }
 }
 async function runRepl(opts) {
     let currentLocale = opts.locale;
     let currentMode = opts.mode;
     let currentAgent = opts.agent;
+    let currentCreds = opts.creds;
+    let currentOffline = opts.offline;
     let turn = 0;
     const t = () => uiStrings(currentLocale);
+    const resolveCreds = () => {
+        if (currentOffline) {
+            try {
+                const live = resolveActiveCredentials();
+                if (live) {
+                    currentOffline = false;
+                    currentCreds = live;
+                    return live;
+                }
+            }
+            catch {
+                /* stay offline */
+            }
+            return null;
+        }
+        try {
+            currentCreds = resolveAgentCredentials(opts.apiKey, currentLocale);
+            return currentCreds;
+        }
+        catch {
+            return currentCreds;
+        }
+    };
     while (true) {
         const line = (await askWithPlaceholder({
             prompt: formatInputPrompt(),
@@ -351,6 +483,15 @@ async function runRepl(opts) {
         })).trim();
         if (!line || line === "exit" || line === "quit" || line === "sair" || line === "退出")
             break;
+        if (isProvidersMetaCommand(line.trim().split(/\s+/)[0] ?? "")) {
+            await runProvidersInteractive(currentLocale);
+            const live = resolveActiveCredentials();
+            if (live) {
+                currentOffline = false;
+                currentCreds = live;
+            }
+            continue;
+        }
         const meta = handleMetaCommand(line, currentLocale, opts.cwd, currentMode);
         if (meta?.kind === "handled")
             continue;
@@ -369,7 +510,14 @@ async function runRepl(opts) {
                     }
                 }
                 else {
-                    currentAgent = await recreateAgentForMode(opts.cwd, currentAgent, currentMode, opts.apiKey);
+                    const creds = resolveCreds();
+                    if (creds && usesCursorSdk(creds)) {
+                        currentAgent = await recreateAgentForMode(opts.cwd, currentAgent, currentMode, opts.apiKey, currentLocale);
+                    }
+                    else if (currentAgent) {
+                        await disposeAgent(currentAgent);
+                        currentAgent = null;
+                    }
                 }
             }
             catch (err) {
@@ -378,8 +526,13 @@ async function runRepl(opts) {
             continue;
         }
         if (meta?.kind === "resume") {
-            if (currentMode === "ask") {
-                warn(currentLocale === "pt" ? "Sessões Cursor só em modo agent/plan." : "Cursor sessions only in agent/plan mode.");
+            const resumeCreds = resolveCreds();
+            if (currentMode === "ask" || !resumeCreds || !usesCursorSdk(resumeCreds)) {
+                warn(currentLocale === "pt"
+                    ? "Sessões guardadas só com provider Cursor."
+                    : currentLocale === "zh"
+                        ? "保存的会话仅适用于 Cursor。"
+                        : "Saved sessions are Cursor-only.");
                 continue;
             }
             try {
@@ -387,7 +540,7 @@ async function runRepl(opts) {
                     fail(currentLocale === "pt" ? "Sem agente activo." : "No active agent.");
                     continue;
                 }
-                currentAgent = await resumeAgentInRepl(opts.cwd, currentAgent, meta.agentId, currentLocale);
+                currentAgent = await resumeAgentInRepl(opts.cwd, currentAgent, meta.agentId, currentLocale, opts.apiKey);
             }
             catch (err) {
                 fail(err instanceof Error ? err.message : String(err));
@@ -395,8 +548,13 @@ async function runRepl(opts) {
             continue;
         }
         if (meta?.kind === "save") {
-            if (!currentAgent) {
-                warn(currentLocale === "pt" ? "Guardar sessão só em modo agent/plan." : "Save session only in agent/plan mode.");
+            const saveCreds = resolveCreds();
+            if (!currentAgent || !saveCreds || !usesCursorSdk(saveCreds)) {
+                warn(currentLocale === "pt"
+                    ? "Guardar sessão só com provider Cursor."
+                    : currentLocale === "zh"
+                        ? "保存会话仅适用于 Cursor。"
+                        : "Save session is Cursor-only.");
                 continue;
             }
             const model = resolveComposerModel();
@@ -415,35 +573,38 @@ async function runRepl(opts) {
             await executeAskTurn({
                 cwd: opts.cwd,
                 question: line,
-                apiKey: opts.askApiKey,
-                apiUrl: opts.askApiUrl,
-                offline: opts.askOffline,
+                offline: currentOffline || Boolean(opts.askOffline),
                 quiet: true,
+                locale: currentLocale,
             });
             console.log("\n");
             turn++;
             continue;
         }
-        if (!currentAgent) {
-            fail(currentLocale === "pt" ? "Sem agente activo." : "No active agent.");
+        if (currentOffline || !resolveCreds()) {
+            warn(offlineAgentHint(currentLocale));
+            turn++;
             continue;
         }
-        await persistAgent(opts.cwd, currentAgent);
-        const ctx = await buildBootstrapContext(opts.cwd);
-        const prompt = buildAgentPrompt(line, ctx, currentLocale);
-        try {
-            await streamRun(currentAgent, prompt, currentLocale);
-        }
-        catch (err) {
-            if (err instanceof CursorAgentError) {
-                fail(err.message);
-                turn++;
-                continue;
-            }
-            throw err;
+        const creds = currentCreds;
+        if (usesCursorSdk(creds) && !currentAgent) {
+            fail(currentLocale === "pt" ? "Sem agente Cursor activo." : "No active Cursor agent.");
+            continue;
         }
-        console.log("\n");
-        await persistAgent(opts.cwd, currentAgent);
+        if (currentAgent)
+            await persistAgent(opts.cwd, currentAgent, creds);
+        const outcome = await runAgentTurn({
+            cwd: opts.cwd,
+            task: line,
+            creds,
+            locale: currentLocale,
+            mode: currentMode,
+            cursorAgent: currentAgent,
+        });
+        if (outcome.cursorAgent)
+            currentAgent = outcome.cursorAgent;
+        if (currentAgent)
+            await persistAgent(opts.cwd, currentAgent, creds);
         turn++;
     }
     ok(t().goodbye);

package/dist/commands/providers.d.ts

@@ -0,0 +1,4 @@
+export declare function runProvidersCommand(opts: {
+    locale?: string;
+}): Promise<void>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/commands/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/commands/providers.ts"],"names":[],"mappings":"AAGA,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,iBAGlE"}

package/dist/commands/providers.js

@@ -0,0 +1,6 @@
+import { parseLocale } from "../lib/locale.js";
+import { runProvidersInteractive } from "../lib/providers/ui.js";
+export async function runProvidersCommand(opts) {
+    const locale = parseLocale(opts.locale) ?? "pt";
+    await runProvidersInteractive(locale);
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,5 @@
+export declare function runSetupCommand(opts: {
+    locale?: string;
+    force?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/commands/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/commands/setup.ts"],"names":[],"mappings":"AAEA,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,iBAE/E"}

package/dist/commands/setup.js

@@ -0,0 +1,4 @@
+import { runSetupWizard } from "../lib/onboarding.js";
+export async function runSetupCommand(opts) {
+    await runSetupWizard(opts);
+}