@action-llama/action-llama 0.1.4 → 0.2.0

package/dist/setup/prompts.js

@@ -1,381 +1,65 @@
-import { input, select, checkbox, confirm } from "@inquirer/prompts";
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
-import { validateGitHubToken, validateSentryToken, validateSentryProjects, validateAnthropicApiKey, validateOAuthTokenFormat } from "./validators.js";
-import { loadCredential } from "../shared/credentials.js";
-import { CREDENTIALS_DIR } from "../shared/paths.js";
-import { listBuiltinDefinitions, loadDefinition } from "../agents/definitions/loader.js";
-// --- Shared: configure a single agent from a definition ---
-export async function configureAgent(definition, context) {
-    // Agent name
-    const name = await input({
-        message: "Agent name:",
-        default: definition.name,
-        validate: (v) => {
-            const trimmed = v.trim();
-            if (!trimmed)
-                return "Name is required";
-            if (context.existingAgentNames?.includes(trimmed))
-                return `Agent "${trimmed}" already exists`;
-            return true;
-        },
-    });
-    // Repos
-    const repoChoices = context.availableRepos.map((r) => ({
-        name: r.fullName,
-        value: r.fullName,
-    }));
-    const repos = await checkbox({
-        message: `Repos for ${name}:`,
-        choices: repoChoices,
-        validate: (v) => (v.length > 0 ? true : "Select at least one repo"),
-    });
-    // Credentials — handle required and optional
-    const credentials = [...definition.credentials.required];
-    let sentryToken;
-    let sentryOrg;
-    let sentryProjectSlugs = [];
-    for (const cred of definition.credentials.optional) {
-        if (cred === "sentry-token") {
-            const result = await promptSentryCredential();
-            sentryToken = result.sentryToken;
-            sentryOrg = result.sentryOrg;
-            sentryProjectSlugs = result.sentryProjectSlugs;
-            if (sentryToken) {
-                credentials.push("sentry-token");
-            }
-        }
-    }
-    // Params — prompt for each non-credential param; resolve credential params
-    const params = {};
-    for (const [key, paramDef] of Object.entries(definition.params)) {
-        // Credential-linked params are populated by the credential handler above
-        if (paramDef.credential === "sentry-token") {
-            if (key === "sentryOrg" && sentryOrg) {
-                params[key] = sentryOrg;
-            }
-            else if (key === "sentryProjects" && sentryProjectSlugs.length > 0) {
-                params[key] = sentryProjectSlugs;
-            }
-            continue;
-        }
-        // Resolve special defaults
-        let defaultValue = paramDef.default;
-        if (defaultValue === "$githubUser") {
-            defaultValue = context.githubUser;
-        }
-        if (paramDef.type === "string") {
-            const value = await input({
-                message: `${paramDef.description}:`,
-                default: defaultValue,
-                ...(paramDef.required ? { validate: (v) => v.trim().length > 0 ? true : `${key} is required` } : {}),
-            });
-            if (value.trim()) {
-                params[key] = value.trim();
-            }
-        }
-        else if (paramDef.type === "string[]") {
-            const value = await input({
-                message: `${paramDef.description} (comma-separated):`,
-                default: defaultValue,
-            });
-            if (value.trim()) {
-                params[key] = value.split(",").map((s) => s.trim()).filter(Boolean);
-            }
-        }
-    }
-    // Webhook trigger
-    const useWebhooks = await confirm({
-        message: `Listen for webhooks? (${definition.webhooks.description})`,
-        default: true,
-    });
-    let webhooks;
-    if (useWebhooks) {
-        const filter = buildWebhookFilter(definition, repos, params);
-        webhooks = { filters: [filter] };
-    }
-    // Schedule trigger
-    const useSchedule = await confirm({
-        message: "Also run on a schedule (polling)?",
-        default: !useWebhooks,
-    });
-    let schedule;
-    if (useSchedule) {
-        schedule = await input({
-            message: `${name} poll interval (cron):`,
-            default: definition.defaultSchedule,
-        });
-    }
-    // Select prompt based on trigger mode
-    const prompt = useWebhooks ? definition.prompts.webhook : definition.prompts.schedule;
-    // Webhook secret
-    let githubWebhookSecret;
-    if (useWebhooks) {
-        const existingSecret = loadCredential("github-webhook-secret");
-        if (!existingSecret) {
-            githubWebhookSecret = (await input({
-                message: "GitHub webhook secret (set this same value in your GitHub webhook settings):",
-                validate: (v) => (v.trim().length > 0 ? true : "Secret is required to verify webhook payloads"),
-            })).trim();
-        }
+import { select } from "@inquirer/prompts";
+import { validateGitHubToken } from "./validators.js";
+import { writeCredential, writeStructuredCredential } from "../shared/credentials.js";
+import { resolveCredential } from "../credentials/registry.js";
+import { promptCredential } from "../credentials/prompter.js";
+/**
+ * Write credential values to disk based on the definition's field count.
+ * Single-field: plain text (backward compatible). Multi-field: JSON.
+ */
+function writeCredentialValues(def, values) {
+    if (Object.keys(values).length === 0)
+        return; // e.g. pi_auth
+    if (def.fields.length === 1) {
+        const fieldName = def.fields[0].name;
+        writeCredential(def.filename, values[fieldName]);
     }
-    // Build agent config
-    const config = {
-        name,
-        credentials,
-        model: context.modelConfig,
-        prompt,
-        repos,
-        ...(schedule ? { schedule } : {}),
-        ...(webhooks ? { webhooks } : {}),
-        ...(Object.keys(params).length > 0 ? { params } : {}),
-    };
-    return {
-        agent: { name, template: definition.name, config },
-        secrets: { sentryToken, githubWebhookSecret },
-        usesWebhooks: useWebhooks,
-    };
-}
-// --- Build webhook filter from definition + params ---
-function buildWebhookFilter(definition, repos, params) {
-    const filter = {
-        source: "github",
-        repos,
-        events: definition.webhooks.events,
-        actions: definition.webhooks.actions,
-    };
-    // Inject param values into filter via webhookFilter mappings
-    for (const [key, paramDef] of Object.entries(definition.params)) {
-        if (paramDef.webhookFilter && params[key] !== undefined) {
-            const value = params[key];
-            const field = paramDef.webhookFilter.field;
-            if (paramDef.webhookFilter.wrap === "array") {
-                filter[field] = [value];
-            }
-            else {
-                filter[field] = value;
-            }
-        }
+    else {
+        writeStructuredCredential(def.filename, values);
     }
-    return filter;
 }
-// --- Sentry credential handler ---
-async function promptSentryCredential() {
-    let sentryToken;
-    let sentryOrg;
-    let sentryProjectSlugs = [];
-    const existingSentryToken = loadCredential("sentry-token");
-    if (existingSentryToken) {
-        const reuse = await confirm({
-            message: `Found existing Sentry token in ${CREDENTIALS_DIR}/sentry-token. Use it?`,
-            default: true,
-        });
-        if (reuse) {
-            sentryToken = existingSentryToken;
-        }
-    }
-    if (!sentryToken) {
-        const useSentry = await confirm({
-            message: "Configure Sentry integration?",
-            default: false,
-        });
-        if (useSentry) {
-            sentryToken = (await input({
-                message: "Sentry auth token:",
-                validate: (v) => (v.trim().length > 0 ? true : "Token is required"),
-            })).trim();
-        }
-    }
-    if (sentryToken) {
-        console.log("Validating Sentry token...");
-        try {
-            const { organizations } = await validateSentryToken(sentryToken);
-            if (organizations.length === 0)
-                throw new Error("No organizations found");
-            if (organizations.length === 1) {
-                sentryOrg = organizations[0].slug;
-                console.log(`Organization: ${sentryOrg}\n`);
-            }
-            else {
-                sentryOrg = await select({
-                    message: "Select Sentry organization:",
-                    choices: organizations.map((o) => ({ name: `${o.name} (${o.slug})`, value: o.slug })),
-                });
-            }
-            const { projects } = await validateSentryProjects(sentryToken, sentryOrg);
-            if (projects.length > 0) {
-                sentryProjectSlugs = await checkbox({
-                    message: "Select Sentry projects to monitor:",
-                    choices: projects.map((p) => ({ name: p.name, value: p.slug })),
-                });
-            }
-        }
-        catch (err) {
-            console.log(`Sentry validation failed: ${err.message}. Skipping Sentry.\n`);
-            sentryToken = undefined;
-        }
+/**
+ * Prompt for a credential and write it to disk.
+ * Returns the prompt result (values + optional params), or undefined if skipped.
+ */
+async function promptAndStoreCredential(def) {
+    const result = await promptCredential(def);
+    if (result && Object.keys(result.values).length > 0) {
+        writeCredentialValues(def, result.values);
     }
-    return { sentryToken, sentryOrg, sentryProjectSlugs };
+    return result;
 }
 // --- Full interactive setup (new command) ---
 export async function runSetup() {
     console.log("\n=== Action Llama — Setup ===\n");
-    // Step 1: Agent Selection
-    console.log("--- Step 1: Agents ---\n");
-    const builtinDefs = listBuiltinDefinitions();
-    const selectedDefNames = await checkbox({
-        message: "Which agents do you want to create?",
-        choices: builtinDefs.map((d) => ({
-            name: `${d.name} — ${d.label} (${d.description})`,
-            value: d.name,
-        })),
-        validate: (v) => (v.length > 0 ? true : "Select at least one agent"),
-    });
-    const selectedDefs = selectedDefNames.map((name) => loadDefinition(name));
-    // Collect all required/optional credentials from selected definitions
-    const allOptionalCredentials = new Set();
-    for (const def of selectedDefs) {
-        for (const cred of def.credentials.optional) {
-            allOptionalCredentials.add(cred);
-        }
-    }
-    // Step 2: Credentials
-    console.log("\n--- Step 2: Credentials ---\n");
+    // Step 1: Credentials
+    console.log("--- Step 1: Credentials ---\n");
     // GitHub token (always required)
-    const existingGithubToken = loadCredential("github-token");
-    let githubToken;
-    if (existingGithubToken) {
-        const reuse = await confirm({
-            message: `Found existing GitHub token in ${CREDENTIALS_DIR}/github-token. Use it?`,
-            default: true,
-        });
-        if (reuse) {
-            githubToken = existingGithubToken;
-        }
-        else {
-            githubToken = (await input({
-                message: "GitHub Personal Access Token (needs repo, workflow scopes):",
-                validate: (v) => (v.trim().length > 0 ? true : "Token is required"),
-            })).trim();
-        }
-    }
-    else {
-        githubToken = (await input({
-            message: "GitHub Personal Access Token (needs repo, workflow scopes):",
-            validate: (v) => (v.trim().length > 0 ? true : "Token is required"),
-        })).trim();
-    }
+    const githubTokenDef = resolveCredential("github-token");
+    const githubTokenResult = await promptAndStoreCredential(githubTokenDef);
+    if (!githubTokenResult)
+        throw new Error("GitHub token is required");
+    const githubToken = githubTokenResult.values.token;
     console.log("Validating GitHub token...");
-    let githubUser;
-    let availableRepos;
     try {
         const result = await validateGitHubToken(githubToken);
-        githubUser = result.user;
-        availableRepos = result.repos;
-        console.log(`Authenticated as: ${githubUser} (${availableRepos.length} repos found)\n`);
+        console.log(`Authenticated as: ${result.user} (${result.repos.length} repos found)\n`);
     }
     catch (err) {
         throw new Error(`GitHub validation failed: ${err.message}`);
     }
     // SSH key
     console.log("--- Git SSH Key ---\n");
-    const existingSshKey = existsSync(resolve(CREDENTIALS_DIR, "id_rsa"));
-    let sshKey;
-    if (existingSshKey) {
-        const reuse = await confirm({
-            message: `Found existing SSH key in ${CREDENTIALS_DIR}/id_rsa. Use it?`,
-            default: true,
-        });
-        if (!reuse) {
-            sshKey = await promptSshKey();
-        }
-    }
-    else {
-        sshKey = await promptSshKey();
-    }
-    // Sentry token (only if any selected definition has it as optional)
-    let sentryToken;
-    let sentryOrg;
-    let sentryProjectSlugs = [];
-    if (allOptionalCredentials.has("sentry-token")) {
-        console.log("\n--- Sentry ---\n");
-        const existingSentryToken = loadCredential("sentry-token");
-        if (existingSentryToken) {
-            const reuse = await confirm({
-                message: `Found existing Sentry token in ${CREDENTIALS_DIR}/sentry-token. Use it?`,
-                default: true,
-            });
-            if (reuse) {
-                sentryToken = existingSentryToken;
-            }
-        }
-        if (!sentryToken) {
-            const useSentry = await confirm({
-                message: "Configure Sentry integration?",
-                default: false,
-            });
-            if (useSentry) {
-                sentryToken = (await input({
-                    message: "Sentry auth token:",
-                    validate: (v) => (v.trim().length > 0 ? true : "Token is required"),
-                })).trim();
-            }
-        }
-        if (sentryToken) {
-            console.log("Validating Sentry token...");
-            try {
-                const { organizations } = await validateSentryToken(sentryToken);
-                if (organizations.length === 0) {
-                    throw new Error("No organizations found");
-                }
-                if (organizations.length === 1) {
-                    sentryOrg = organizations[0].slug;
-                    console.log(`Organization: ${sentryOrg}\n`);
-                }
-                else {
-                    sentryOrg = await select({
-                        message: "Select Sentry organization:",
-                        choices: organizations.map((o) => ({ name: `${o.name} (${o.slug})`, value: o.slug })),
-                    });
-                }
-                const { projects } = await validateSentryProjects(sentryToken, sentryOrg);
-                if (projects.length > 0) {
-                    sentryProjectSlugs = await checkbox({
-                        message: "Select Sentry projects to monitor:",
-                        choices: projects.map((p) => ({ name: p.name, value: p.slug })),
-                    });
-                }
-            }
-            catch (err) {
-                console.log(`Sentry validation failed: ${err.message}. Skipping Sentry.\n`);
-                sentryToken = undefined;
-            }
-        }
-    }
+    const sshKeyDef = resolveCredential("id_rsa");
+    const sshKeyResult = await promptAndStoreCredential(sshKeyDef);
+    const sshKey = sshKeyResult?.values.key;
     // Anthropic auth
     console.log("\n--- Anthropic Auth ---\n");
-    const existingAnthropicKey = loadCredential("anthropic-key");
-    let authType;
-    let anthropicKey;
-    if (existingAnthropicKey) {
-        const reuse = await confirm({
-            message: `Found existing Anthropic credential in ${CREDENTIALS_DIR}/anthropic-key. Use it?`,
-            default: true,
-        });
-        if (reuse) {
-            anthropicKey = existingAnthropicKey;
-            authType = anthropicKey.includes("sk-ant-oat") ? "oauth_token" : "api_key";
-            console.log(`Using existing credential (detected type: ${authType}).\n`);
-        }
-        else {
-            ({ authType, anthropicKey } = await promptAnthropicAuth());
-        }
-    }
-    else {
-        ({ authType, anthropicKey } = await promptAnthropicAuth());
-    }
-    // Step 3: LLM defaults
-    console.log("\n--- Step 3: LLM Defaults ---\n");
+    const anthropicDef = resolveCredential("anthropic-key");
+    const anthropicResult = await promptAndStoreCredential(anthropicDef);
+    const anthropicKey = anthropicResult?.values.token;
+    // Step 2: LLM defaults
+    console.log("\n--- Step 2: LLM Defaults ---\n");
     const modelName = await select({
         message: "Select model:",
         choices: [
@@ -385,7 +69,7 @@ export async function runSetup() {
         ],
         default: "claude-sonnet-4-20250514",
     });
-    const thinkingLevel = await select({
+    await select({
         message: "Thinking level:",
         choices: [
             { name: "off", value: "off" },
@@ -396,261 +80,15 @@ export async function runSetup() {
         ],
         default: "medium",
     });
-    const modelConfig = {
-        provider: "anthropic",
-        model: modelName,
-        thinkingLevel,
-        authType,
-    };
-    // Step 4: Configure each agent
-    console.log("\n--- Step 4: Configure Agents ---\n");
-    const agents = [];
-    let anyWebhooks = false;
-    let firstGithubWebhookSecret;
-    for (const def of selectedDefs) {
-        console.log(`\n  --- Configure ${def.name} agent ---\n`);
-        // For init flow, we pre-populate sentry params from the top-level credential gathering
-        // so we skip the per-agent sentry prompt.
-        // We accomplish this by building params for credential-linked params here.
-        const prePopulatedParams = {};
-        for (const [key, paramDef] of Object.entries(def.params)) {
-            if (paramDef.credential === "sentry-token") {
-                if (key === "sentryOrg" && sentryOrg) {
-                    prePopulatedParams[key] = sentryOrg;
-                }
-                else if (key === "sentryProjects" && sentryProjectSlugs.length > 0) {
-                    prePopulatedParams[key] = sentryProjectSlugs;
-                }
-            }
-        }
-        // Use configureAgentInit for init flow (skips credential prompts done globally)
-        const result = await configureAgentInit(def, {
-            availableRepos,
-            githubUser,
-            modelConfig,
-        }, prePopulatedParams, sentryToken ? true : false);
-        if (result.usesWebhooks) {
-            anyWebhooks = true;
-            if (!firstGithubWebhookSecret) {
-                firstGithubWebhookSecret = result.secrets.githubWebhookSecret;
-            }
-        }
-        agents.push(result.agent);
-    }
-    // GitHub webhook secret (if any agent uses webhooks and not already prompted)
-    let githubWebhookSecret = firstGithubWebhookSecret;
-    if (anyWebhooks && !githubWebhookSecret) {
-        console.log("\n--- GitHub Webhook Secret ---\n");
-        const existingSecret = loadCredential("github-webhook-secret");
-        if (existingSecret) {
-            const reuse = await confirm({
-                message: `Found existing webhook secret in ${CREDENTIALS_DIR}/github-webhook-secret. Use it?`,
-                default: true,
-            });
-            if (reuse) {
-                githubWebhookSecret = existingSecret;
-            }
-        }
-        if (!githubWebhookSecret) {
-            githubWebhookSecret = (await input({
-                message: "GitHub webhook secret (set this same value in your GitHub webhook settings):",
-                validate: (v) => (v.trim().length > 0 ? true : "Secret is required to verify webhook payloads"),
-            })).trim();
-        }
-    }
     // Build global config
     const globalConfig = {};
-    if (githubWebhookSecret) {
-        globalConfig.webhooks = { githubSecretCredential: "github-webhook-secret" };
-    }
     return {
         globalConfig,
-        agents,
         secrets: {
             githubToken,
-            sentryToken,
             anthropicKey,
             sshKey,
-            githubWebhookSecret,
         },
     };
 }
-/**
- * Init-flow variant: configures an agent from a definition, but skips optional
- * credential prompts (those were handled globally in runSetup).
- */
-async function configureAgentInit(definition, context, prePopulatedParams, hasSentryToken) {
-    const name = await input({
-        message: `Agent name:`,
-        default: definition.name,
-    });
-    const repoChoices = context.availableRepos.map((r) => ({
-        name: r.fullName,
-        value: r.fullName,
-    }));
-    const repos = await checkbox({
-        message: `Repos for ${name}:`,
-        choices: repoChoices,
-        validate: (v) => (v.length > 0 ? true : "Select at least one repo"),
-    });
-    // Credentials from definition
-    const credentials = [...definition.credentials.required];
-    if (hasSentryToken && definition.credentials.optional.includes("sentry-token")) {
-        credentials.push("sentry-token");
-    }
-    // Params — prompt for non-credential params, use pre-populated for credential params
-    const params = { ...prePopulatedParams };
-    for (const [key, paramDef] of Object.entries(definition.params)) {
-        if (paramDef.credential)
-            continue; // Already handled
-        let defaultValue = paramDef.default;
-        if (defaultValue === "$githubUser") {
-            defaultValue = context.githubUser;
-        }
-        if (paramDef.type === "string") {
-            const value = await input({
-                message: `${paramDef.description}:`,
-                default: defaultValue,
-                ...(paramDef.required ? { validate: (v) => v.trim().length > 0 ? true : `${key} is required` } : {}),
-            });
-            if (value.trim()) {
-                params[key] = value.trim();
-            }
-        }
-        else if (paramDef.type === "string[]") {
-            const value = await input({
-                message: `${paramDef.description} (comma-separated):`,
-                default: defaultValue,
-            });
-            if (value.trim()) {
-                params[key] = value.split(",").map((s) => s.trim()).filter(Boolean);
-            }
-        }
-    }
-    // Webhook trigger
-    const useWebhooks = await confirm({
-        message: `Listen for webhooks? (${definition.webhooks.description})`,
-        default: true,
-    });
-    let webhooks;
-    if (useWebhooks) {
-        const filter = buildWebhookFilter(definition, repos, params);
-        webhooks = { filters: [filter] };
-    }
-    // Schedule trigger
-    const useSchedule = await confirm({
-        message: `Also run on a schedule (polling)?`,
-        default: !useWebhooks,
-    });
-    let schedule;
-    if (useSchedule) {
-        schedule = await input({
-            message: `${name} poll interval (cron):`,
-            default: definition.defaultSchedule,
-        });
-    }
-    const prompt = useWebhooks ? definition.prompts.webhook : definition.prompts.schedule;
-    // Build agent config
-    const config = {
-        name,
-        credentials,
-        model: context.modelConfig,
-        prompt,
-        repos,
-        ...(schedule ? { schedule } : {}),
-        ...(webhooks ? { webhooks } : {}),
-        ...(Object.keys(params).length > 0 ? { params } : {}),
-    };
-    return {
-        agent: { name, template: definition.name, config },
-        secrets: {},
-        usesWebhooks: useWebhooks,
-    };
-}
-// --- Add agent to existing project ---
-export async function runAddAgent(opts) {
-    console.log("\n=== Action Llama — Add Agent ===\n");
-    const result = await configureAgent(opts.definition, {
-        availableRepos: opts.availableRepos,
-        githubUser: opts.githubUser,
-        modelConfig: opts.modelConfig,
-        existingAgentNames: opts.existingAgentNames,
-    });
-    return {
-        agent: result.agent,
-        secrets: result.secrets,
-    };
-}
-// --- SSH key prompt ---
-async function promptSshKey() {
-    const defaultPath = resolve(process.env.HOME || "~", ".ssh", "id_rsa");
-    const keyPath = await input({
-        message: `Path to SSH private key for git operations (leave empty to use system default):`,
-        default: existsSync(defaultPath) ? defaultPath : "",
-    });
-    if (!keyPath.trim()) {
-        console.log("No SSH key configured — git will use your system SSH config.\n");
-        return undefined;
-    }
-    const resolvedPath = resolve(keyPath.trim());
-    if (!existsSync(resolvedPath)) {
-        throw new Error(`SSH key not found at ${resolvedPath}`);
-    }
-    const content = readFileSync(resolvedPath, "utf-8");
-    console.log("SSH key loaded.\n");
-    return content;
-}
-// --- Anthropic auth prompt ---
-async function promptAnthropicAuth() {
-    const authMethod = await select({
-        message: "How do you want to authenticate with Anthropic?",
-        choices: [
-            { name: "Use existing pi auth (already ran `pi /login` or `claude setup-token`)", value: "pi_auth" },
-            { name: "Enter an API key (sk-ant-api...)", value: "api_key" },
-            { name: "Enter an OAuth token (sk-ant-oat...)", value: "oauth_token" },
-        ],
-    });
-    if (authMethod === "pi_auth") {
-        const { AuthStorage, ModelRegistry } = await import("@mariozechner/pi-coding-agent");
-        const authStorage = AuthStorage.create();
-        const registry = new ModelRegistry(authStorage);
-        const available = await registry.getAvailable();
-        const hasAnthropic = available.some((m) => m.provider === "anthropic");
-        if (!hasAnthropic) {
-            throw new Error("No Anthropic credentials found in pi auth storage (~/.pi/agent/auth.json). " +
-                "Run `pi /login` first, or choose a different auth method.");
-        }
-        console.log("Found existing Anthropic credentials in pi auth storage.\n");
-        return { authType: "pi_auth", anthropicKey: undefined };
-    }
-    else if (authMethod === "api_key") {
-        let anthropicKey = (await input({
-            message: "Anthropic API key:",
-            validate: (v) => (v.trim().length > 0 ? true : "Key is required"),
-        })).trim();
-        console.log("Validating API key...");
-        try {
-            await validateAnthropicApiKey(anthropicKey);
-            console.log("API key validated.\n");
-        }
-        catch (err) {
-            throw new Error(`Anthropic validation failed: ${err.message}`);
-        }
-        return { authType: "api_key", anthropicKey };
-    }
-    else {
-        let anthropicKey = (await input({
-            message: "Anthropic OAuth token (from `claude setup-token`):",
-            validate: (v) => (v.trim().length > 0 ? true : "Token is required"),
-        })).trim();
-        try {
-            validateOAuthTokenFormat(anthropicKey);
-            console.log("OAuth token format looks valid. It will be verified on first agent run.\n");
-        }
-        catch (err) {
-            throw new Error(err.message);
-        }
-        return { authType: "oauth_token", anthropicKey };
-    }
-}
 //# sourceMappingURL=prompts.js.map