@chenpengfei/daily-brief 0.1.1 → 0.1.3

package/dist/src/cli.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { stdin as processStdin, stdout as processStdout } from "node:process";
 import { createInterface } from "node:readline/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { deliverOnce, generateOnce, loginModelCredential, logoutModelCredential, readModelRuntimeConfig, runOnce, statusModelCredentials, toApiKeyCredential } from "./agent/index.js";
-import { collectSources } from "./collection/index.js";
-import { resolveConfiguredWebhookUrl } from "./discord/index.js";
-import { defaultModelConfig, dateFromDateKey, formatDateKey, formatSourceRegistry, loadSourceRegistry, putCredential, readDeliveryConfig, readConfiguredTimezone, getCredential, resolveDailyBriefPaths, setSourceEnabled, validateSourceRegistry, writeDeliveryConfig, writeCredentialStore, writeModelConfig } from "./config/index.js";
+import { stringify } from "yaml";
+import { loginModelCredential, readModelRuntimeConfig, runOnce, toApiKeyCredential } from "./agent/index.js";
+import { defaultModelConfig, dateFromDateKey, formatDateKey, formatSourceRegistry, loadSourceRegistry, putCredential, readDeliveryConfig, readDailyBriefConfig, getCredential, resolveDailyBriefPaths, setSourceEnabled, validateSourceRegistry, writeDeliveryConfig, writeCredentialStore, writeModelConfig } from "./config/index.js";
 import { getOperationalStatus } from "./workflow/index.js";
 const consoleIo = {
+    interactive: Boolean(processStdin.isTTY && processStdout.isTTY),
     stdout(line) {
         console.log(line);
     },
@@ -16,7 +17,10 @@ const consoleIo = {
         console.error(line);
     },
     async prompt(message) {
-        const reader = createInterface({ input: processStdin, output: processStdout });
+        if (!processStdin.isTTY || !processStdout.isTTY) {
+            throw new Error(nonInteractiveSetupMessage());
+        }
+        const reader = createInterface({ input: processStdin, output: processStdout, terminal: false });
         try {
             return await reader.question(`${message} `);
         }
@@ -27,75 +31,138 @@ const consoleIo = {
 };
 export async function runCli(args, io = consoleIo, env = process.env) {
     const [command, subcommand, value] = args;
-    const workflowFlags = parseFlags(args.slice(1));
-    const options = {
-        ...optionsFromEnv(env),
-        ...readWorkflowDateOption(workflowFlags, env)
-    };
     if (!command || command === "help" || command === "--help" || command === "-h") {
         printHelp(io);
         return;
     }
+    if (command === "version" || command === "--version" || command === "-v") {
+        io.stdout(await readPackageVersion());
+        return;
+    }
     if (command === "run-once") {
+        const workflowFlags = parseFlags(args.slice(1));
+        const options = {
+            ...optionsFromEnv(env),
+            ...readWorkflowDateOption(workflowFlags)
+        };
         await assertWorkflowConfigured(options.sourceRegistryPath);
-        const result = await runOnce(options);
+        io.stdout("Daily Brief run started");
+        io.stdout(`Date: ${options.dateKey}`);
+        io.stdout(`Home: ${resolveDailyBriefPaths(env).home}`);
+        io.stdout("");
+        const result = await runOnce({
+            ...options,
+            onProgress(line) {
+                io.stdout(line);
+            }
+        });
         if (result.coreFailure) {
             throw new Error(`Core Workflow Failure: ${result.coreFailure.kind}\n${result.coreFailure.message}`);
         }
+        io.stdout("");
         io.stdout(`Daily Brief archived: ${result.archivePath}`);
         io.stdout(`Sources read: ${result.sourceCount}`);
         io.stdout(`Source Items read: ${result.sourceItemCount}`);
-        io.stdout(`Discord delivery: ${result.delivery.status}`);
-        io.stdout(`Pi events: ${result.piEvents.join(", ")}`);
+        io.stdout(`Agent stages completed: ${countAgentStageEvents(result.piEvents)}/5`);
+        io.stdout(`Discord delivery: ${formatDeliveryStatus(result.delivery)}`);
+        io.stdout("5/5 Run completed");
         return;
     }
     if (command === "setup") {
         await handleSetupCommand(args.slice(1), io, env);
         return;
     }
-    if (command === "collect") {
-        await assertWorkflowConfigured(options.sourceRegistryPath);
-        const result = await collectSources(options);
-        io.stdout(`Source Item Store: ${result.storePath || "(no items written)"}`);
-        for (const source of result.sources) {
-            io.stdout(`${source.status.padEnd(7)} ${source.sourceId} items=${source.itemCount} written=${source.writtenCount} duplicates=${source.skippedDuplicateCount}${source.reason ? ` reason=${source.reason}` : ""}`);
-        }
-        return;
-    }
-    if (command === "generate") {
-        const result = await generateOnce(options);
-        io.stdout(`Daily Brief archived: ${result.archivePath}`);
-        io.stdout(`Source Items read: ${result.sourceItemCount}`);
-        return;
-    }
-    if (command === "deliver") {
-        const result = await deliverOnce(options);
-        io.stdout(`Discord delivery: ${result.status}${"reason" in result ? ` (${result.reason})` : ""}`);
-        return;
-    }
     if (command === "status") {
-        const status = await getOperationalStatus(options);
-        io.stdout(`${status.health}: ${status.message}`);
-        for (const failure of status.materialPartialFailures) {
-            io.stdout(`- ${failure}`);
+        if (args.length > 1) {
+            throw new Error("daily-brief status does not accept flags.");
         }
+        const options = optionsFromEnv(env);
+        const status = await getOperationalStatus(options);
+        printOperationalStatus(status, io);
         return;
     }
     if (command === "sources") {
+        const options = optionsFromEnv(env);
         await handleSourcesCommand(subcommand, value, io, options.sourceRegistryPath);
         return;
     }
-    if (command === "model") {
-        await handleModelCommand(args.slice(1), io, env);
-        return;
+    throw new Error(`Unknown command: ${command}`);
+}
+async function readPackageVersion() {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (let index = 0; index < 8; index += 1) {
+        const path = join(directory, "package.json");
+        try {
+            const packageJson = JSON.parse(await readFile(path, "utf8"));
+            if (isRecord(packageJson) && typeof packageJson.version === "string") {
+                return `daily-brief ${packageJson.version}`;
+            }
+        }
+        catch (error) {
+            if (!(isNodeError(error) && error.code === "ENOENT")) {
+                throw error;
+            }
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            break;
+        }
+        directory = parent;
     }
-    if (command === "delivery") {
-        await handleDeliveryCommand(args.slice(1), io, env);
-        return;
+    return "daily-brief unknown";
+}
+function countAgentStageEvents(events) {
+    return events.length > 0 ? 5 : 0;
+}
+function formatDeliveryStatus(delivery) {
+    return `${delivery.status}${delivery.reason ? ` (${delivery.reason})` : ""}`;
+}
+function printOperationalStatus(status, io) {
+    io.stdout("Daily Brief status");
+    io.stdout(`Health: ${status.health} - ${status.message}`);
+    io.stdout(`Date: ${status.dateKey}`);
+    io.stdout(`System timezone: ${status.systemTimezone}`);
+    io.stdout(`Home: ${status.paths.home}`);
+    io.stdout(`Data: ${status.paths.dataHome}`);
+    io.stdout("");
+    io.stdout("Setup readiness");
+    io.stdout(formatStatusCheck("Config", status.setup.config));
+    io.stdout(formatSourceRegistryCheck(status.setup.sourceRegistry));
+    io.stdout(formatModelCheck(status.setup.model));
+    io.stdout(formatStatusCheck("Delivery", status.setup.delivery));
+    io.stdout(formatStatusCheck("Data", status.setup.data));
+    io.stdout("");
+    io.stdout("Today run state");
+    io.stdout(formatStatusCheck("Source Items", status.today.sourceItems));
+    io.stdout(formatStatusCheck("Brief Archive", status.today.briefArchive));
+    io.stdout(formatStatusCheck("Agent Run Artifacts", status.today.agentRunArtifacts));
+    io.stdout("");
+    io.stdout(`Next: ${status.nextAction}`);
+    for (const failure of status.materialPartialFailures) {
+        io.stdout(`- ${failure}`);
     }
-    throw new Error(`Unknown command: ${command}`);
 }
-function readWorkflowDateOption(flags, env) {
+function formatStatusCheck(label, check) {
+    const detail = check.detail ? ` - ${check.detail}` : "";
+    const path = check.path ? ` (${check.path})` : "";
+    return `- ${label}: ${check.state} - ${check.label}${detail}${path}`;
+}
+function formatSourceRegistryCheck(check) {
+    const counts = typeof check.enabledCount === "number" && typeof check.totalCount === "number"
+        ? ` - ${check.enabledCount}/${check.totalCount} enabled`
+        : "";
+    const detail = check.detail && !counts.includes(check.detail) ? ` - ${check.detail}` : "";
+    const path = check.path ? ` (${check.path})` : "";
+    return `- Source Registry: ${check.state} - ${check.label}${counts}${detail}${path}`;
+}
+function formatModelCheck(check) {
+    const selected = check.provider && check.model ? ` - ${check.provider}/${check.model}` : "";
+    const credential = check.credentialRef ? ` - credential ${check.credentialRef}` : "";
+    const detail = check.detail ? ` - ${check.detail}` : "";
+    const path = check.path ? ` (${check.path})` : "";
+    return `- Model: ${check.state} - ${check.label}${selected}${credential}${detail}${path}`;
+}
+function readWorkflowDateOption(flags) {
     if (flags.date) {
         if (!/^\d{4}-\d{2}-\d{2}$/.test(flags.date)) {
             throw new Error("--date must use YYYY-MM-DD");
@@ -103,8 +170,7 @@ function readWorkflowDateOption(flags, env) {
         return { date: dateFromDateKey(flags.date), dateKey: flags.date };
     }
     const now = new Date();
-    const paths = resolveDailyBriefPaths(env);
-    const timezone = readConfiguredTimezone(paths.configPath) ?? env.TZ ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     return { date: now, dateKey: formatDateKey(now, timezone) };
 }
 async function assertWorkflowConfigured(sourceRegistryPath) {
@@ -119,8 +185,15 @@ async function handleSourcesCommand(subcommand, value, io, sourceRegistryPath) {
     }
     if (subcommand === "edit") {
         const path = sourceRegistryPath ?? resolveDailyBriefPaths().sourceRegistryPath;
-        io.stdout(`Source Registry: ${path}`);
-        io.stdout("Edit this YAML file, then run: daily-brief sources validate");
+        io.stdout("Source Registry:");
+        io.stdout(`  ${path}`);
+        io.stdout("");
+        io.stdout("Edit this YAML file to add, remove, or update Sources.");
+        io.stdout("Use the id field as SOURCE ID for enable/disable commands.");
+        io.stdout("");
+        io.stdout("After editing:");
+        io.stdout("  daily-brief sources validate");
+        io.stdout("  daily-brief sources list");
         return;
     }
     if (subcommand === "validate") {
@@ -138,10 +211,19 @@ async function handleSourcesCommand(subcommand, value, io, sourceRegistryPath) {
     }
     if (subcommand === "enable" || subcommand === "disable") {
         if (!value) {
-            throw new Error(`sources ${subcommand} requires a Source id`);
+            throw new Error(`sources ${subcommand} requires a SOURCE ID. Run daily-brief sources list to see available SOURCE ID values.`);
         }
         const enabled = subcommand === "enable";
-        await setSourceEnabled(value, enabled, sourceRegistryPath);
+        try {
+            await setSourceEnabled(value, enabled, sourceRegistryPath);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message === `Source not found: ${value}`) {
+                throw new Error(`Source not found: ${value}. Run daily-brief sources list to see available SOURCE ID values.`);
+            }
+            throw error;
+        }
         io.stdout(`${enabled ? "Enabled" : "Disabled"} Source: ${value}`);
         return;
     }
@@ -152,117 +234,207 @@ function printHelp(io) {
         "Daily Brief Operational CLI",
         "",
         "Usage:",
-        "  daily-brief setup [--force]",
-        "  daily-brief run-once",
-        "  daily-brief collect",
-        "  daily-brief generate",
-        "  daily-brief deliver",
+        "  daily-brief setup",
+        "  daily-brief run-once [--date YYYY-MM-DD]",
         "  daily-brief status",
-        "  daily-brief model configure [--provider <provider> --model <model> --credential-ref <ref>]",
-        "  daily-brief model login [--provider openai-codex --credential-ref <ref>]",
-        "  daily-brief model logout [--credential-ref <ref>]",
-        "  daily-brief model status",
-        "  daily-brief delivery configure --enabled true|false [--webhook-ref <ref> --webhook-url <url>]",
-        "  daily-brief delivery status",
-        "  daily-brief delivery test",
         "  daily-brief sources list",
         "  daily-brief sources edit",
         "  daily-brief sources validate",
         "  daily-brief sources enable <source-id>",
-        "  daily-brief sources disable <source-id>"
+        "  daily-brief sources disable <source-id>",
+        "  daily-brief version"
     ].join("\n"));
 }
 async function handleSetupCommand(args, io, env) {
     const flags = parseFlags(args);
-    const force = flags.force === "true";
+    if (Object.keys(flags).length > 0 || args.some((arg) => !arg.startsWith("--"))) {
+        throw new Error("daily-brief setup does not accept flags. Re-run setup and choose what to preserve or update interactively.");
+    }
+    requireInteractiveSetup(io);
     const paths = resolveDailyBriefPaths(env);
-    const timezone = env.TZ?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+    const existingConfig = readDailyBriefConfig(paths.configPath);
     await mkdir(paths.home, { recursive: true });
     await mkdir(paths.sourceItemRoot, { recursive: true });
     await mkdir(paths.agentRunRoot, { recursive: true });
     await mkdir(paths.briefArchiveRoot, { recursive: true });
-    await writeIfNeeded(paths.configPath, [
-        `timezone: ${timezone}`,
-        "brief:",
-        "  language: zh",
-        "  maxSignals: 5",
-        "model:",
-        "  provider: openai-codex",
-        "  model: gpt-5.5",
-        "  credentialRef: openai-codex.default",
-        "delivery:",
-        "  enabled: false",
-        ""
-    ].join("\n"), force);
-    await writeIfNeeded(paths.sourceRegistryPath, defaultSourceRegistryExample(), force);
-    if (force || !(await exists(paths.authPath))) {
+    await writeSetupBaseConfig(paths.configPath, {
+        ...existingConfig,
+        brief: normalizeBriefConfig(existingConfig.brief)
+    });
+    if (!(await exists(paths.authPath))) {
         writeCredentialStore({ credentials: {} }, paths.authPath);
     }
+    if (await exists(paths.sourceRegistryPath)) {
+        io.stdout(`Source Registry: ${paths.sourceRegistryPath}`);
+        try {
+            io.stdout(formatSourceRegistry(await loadSourceRegistry(paths.sourceRegistryPath)));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            io.stdout(`Source Registry invalid:\n${message}`);
+        }
+        const reinitialize = await promptYesNo(io, "Reinitialize example Sources? Existing sources.yaml will be overwritten.", false);
+        if (reinitialize) {
+            await writeFile(paths.sourceRegistryPath, defaultSourceRegistryExample(), "utf8");
+            io.stdout("Source Registry reinitialized from the packaged example.");
+        }
+        else {
+            io.stdout("Source Registry preserved.");
+        }
+    }
+    else {
+        await writeFile(paths.sourceRegistryPath, defaultSourceRegistryExample(), "utf8");
+        io.stdout(`Source Registry initialized: ${paths.sourceRegistryPath}`);
+        io.stdout(formatSourceRegistry(await loadSourceRegistry(paths.sourceRegistryPath)));
+    }
+    io.stdout("To edit Sources:");
+    io.stdout("  daily-brief sources edit");
+    io.stdout("  daily-brief sources validate");
+    io.stdout("  daily-brief sources list");
+    await configureModelThroughSetup(io, env);
+    await configureDeliveryThroughSetup(io, env);
+    const readiness = readModelRuntimeConfig(env);
+    const delivery = readDeliveryConfig(paths.configPath);
     io.stdout(`Daily Brief home: ${paths.home}`);
     io.stdout(`Daily Brief data: ${paths.dataHome}`);
-    io.stdout(`Timezone: ${timezone}`);
     io.stdout(`Source Registry: ${paths.sourceRegistryPath}`);
-    io.stdout("Next: daily-brief sources validate");
-    io.stdout("Next: daily-brief model configure");
-    io.stdout("Optional: daily-brief delivery configure --enabled true --webhook-url <url>");
-    io.stdout("Readiness: config files present, Source Registry initialized, data directories writable, delivery disabled");
-}
-async function handleDeliveryCommand(args, io, env) {
-    const [subcommand, ...rest] = args;
-    const flags = parseFlags(rest);
+    io.stdout(`Model: ${readiness.provider}/${readiness.model}`);
+    io.stdout(`Model credential: ${readiness.ready ? "configured" : "missing"}`);
+    io.stdout(`Discord delivery: ${delivery?.enabled ? "enabled" : "disabled"}`);
+    io.stdout("Ready to run:");
+    io.stdout("  daily-brief run-once");
+}
+function requireInteractiveSetup(io) {
+    if (!io.prompt || io.interactive === false) {
+        throw new Error(nonInteractiveSetupMessage());
+    }
+}
+function nonInteractiveSetupMessage() {
+    return [
+        "daily-brief setup requires an interactive terminal.",
+        "For CI or scripted setup, create ~/.daily-brief/config.yaml, ~/.daily-brief/sources.yaml, and ~/.daily-brief/auth.json directly.",
+        "Use DAILY_BRIEF_HOME to choose a configuration root and DAILY_BRIEF_DATA_HOME to choose a generated-data root.",
+        "Run daily-brief sources validate after writing sources.yaml."
+    ].join("\n");
+}
+async function writeSetupBaseConfig(path, config) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, stringify(config), "utf8");
+}
+function normalizeBriefConfig(value) {
+    const current = isRecord(value) ? value : {};
+    return {
+        ...current,
+        language: "zh",
+        maxSignals: typeof current.maxSignals === "number" ? current.maxSignals : 5
+    };
+}
+async function configureModelThroughSetup(io, env) {
     const paths = resolveDailyBriefPaths(env);
-    if (subcommand === "configure") {
-        const enabled = flags.enabled === "true" || flags.enabled === "yes";
-        const webhookRef = flags["webhook-ref"] ?? "discord.default";
-        writeDeliveryConfig({ enabled, ...(enabled ? { webhookRef } : {}) }, paths.configPath);
-        if (enabled && flags["webhook-url"]) {
-            putCredential(webhookRef, { type: "webhook", provider: "discord", webhookUrl: flags["webhook-url"] }, paths.authPath);
-        }
-        io.stdout(`Discord delivery: ${enabled ? "enabled" : "disabled"}`);
-        if (enabled)
-            io.stdout(`Webhook Ref: ${webhookRef}`);
+    const current = readDailyBriefConfig(paths.configPath).model ?? defaultModelConfig();
+    const provider = readProviderFlag(await promptWithDefault(io, "LLM Provider (openai-codex/openai/deepseek/openai-compatible)", current.provider));
+    const model = await promptWithDefault(io, "Model", current.provider === provider ? current.model : defaultModelForProvider(provider));
+    io.stdout("Credential name identifies where Daily Brief finds the model secret in auth.json. Use the default unless you manage multiple credentials.");
+    const credentialRef = await promptWithDefault(io, "Model credential name", current.provider === provider ? current.credentialRef ?? defaultCredentialRef(provider) ?? "" : defaultCredentialRef(provider) ?? "");
+    const baseUrl = provider === "openai-compatible"
+        ? await promptWithDefault(io, "Base URL", current.provider === provider ? current.baseUrl ?? "" : "")
+        : undefined;
+    const config = {
+        provider,
+        model,
+        ...(credentialRef ? { credentialRef } : {}),
+        ...(baseUrl ? { baseUrl } : {})
+    };
+    writeModelConfig(config, paths.configPath);
+    io.stdout(`Model configured: ${provider}/${model}`);
+    if (credentialRef) {
+        io.stdout(`Model credential name: ${credentialRef}`);
+    }
+    await maybeConfigureModelCredential({ provider, credentialRef, io, env });
+}
+async function maybeConfigureModelCredential(input) {
+    if (!input.credentialRef) {
         return;
     }
-    if (subcommand === "status") {
-        const config = readDeliveryConfig(paths.configPath);
-        if (!config?.enabled) {
-            io.stdout("Discord delivery: disabled");
+    const paths = resolveDailyBriefPaths(input.env);
+    if (input.provider === "openai-codex") {
+        const credential = getCredential(input.credentialRef, paths.authPath);
+        if (credential) {
+            input.io.stdout("Model credential: configured");
             return;
         }
-        const credential = config.webhookRef ? getDeliveryWebhookCredential(config.webhookRef, paths.authPath) : undefined;
-        io.stdout("Discord delivery: enabled");
-        io.stdout(`Webhook Ref: ${config.webhookRef ?? "(missing)"}`);
-        io.stdout(`Webhook: ${credential ? "<redacted>" : "(missing)"}`);
-        return;
-    }
-    if (subcommand === "test") {
-        const config = readDeliveryConfig(paths.configPath);
-        const credential = config?.webhookRef ? getDeliveryWebhookCredential(config.webhookRef, paths.authPath) : undefined;
-        if (!config?.enabled || !credential) {
-            throw new Error("delivery test requires enabled Discord delivery with a webhook credential");
+        if (await promptYesNo(input.io, "Login to openai-codex now?", true)) {
+            await loginModelCredential({
+                provider: input.provider,
+                credentialRef: input.credentialRef,
+                io: input.io,
+                env: input.env
+            });
+            input.io.stdout(`Logged in credential: ${input.credentialRef}`);
         }
-        const response = await (io.fetchImpl ?? fetch)(credential.webhookUrl, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ content: "Daily Brief delivery test" })
-        });
-        if (!response.ok) {
-            throw new Error(`Discord delivery test failed with status ${response.status}`);
+        else {
+            input.io.stdout("Model credential: missing");
         }
-        io.stdout("Discord delivery test: sent");
         return;
     }
-    throw new Error(`Unknown delivery command: ${subcommand ?? "(missing)"}`);
-}
-function getDeliveryWebhookCredential(ref, authPath) {
-    const credential = getCredential(ref, authPath);
-    return credential?.type === "webhook" && credential.provider === "discord" ? credential : undefined;
+    if (getCredential(input.credentialRef, paths.authPath)) {
+        input.io.stdout("Model credential: configured");
+        return;
+    }
+    if (await promptYesNo(input.io, "Store API key in credential store? API key input may be visible in this terminal.", false)) {
+        const apiKey = await promptWithDefault(input.io, "API key", "");
+        if (apiKey) {
+            putCredential(input.credentialRef, toApiKeyCredential(input.provider, apiKey), paths.authPath);
+            input.io.stdout(`Stored credential: ${input.credentialRef}`);
+        }
+    }
+    else {
+        input.io.stdout("Model credential: missing");
+    }
 }
-async function writeIfNeeded(path, contents, force) {
-    if (!force && (await exists(path))) {
+async function configureDeliveryThroughSetup(io, env) {
+    const paths = resolveDailyBriefPaths(env);
+    const current = readDeliveryConfig(paths.configPath);
+    const enabled = await promptYesNo(io, "Enable Discord delivery?", current?.enabled ?? false);
+    if (!enabled) {
+        writeDeliveryConfig({ enabled: false }, paths.configPath);
+        io.stdout("Discord delivery: disabled");
         return;
     }
-    await writeFile(path, contents, "utf8");
+    const webhookRef = await promptWithDefault(io, "Discord webhook credential name", current?.webhookRef ?? "discord.default");
+    writeDeliveryConfig({ enabled: true, webhookRef }, paths.configPath);
+    const credential = getCredential(webhookRef, paths.authPath);
+    if (credential) {
+        io.stdout("Discord webhook: configured");
+        if (!(await promptYesNo(io, "Replace Discord webhook URL?", false))) {
+            return;
+        }
+    }
+    const webhookUrl = await promptWithDefault(io, "Discord webhook URL", "");
+    if (webhookUrl) {
+        putCredential(webhookRef, { type: "webhook", provider: "discord", webhookUrl }, paths.authPath);
+        io.stdout(`Discord webhook stored: ${webhookRef}`);
+    }
+    else {
+        io.stdout("Discord webhook: missing");
+    }
+}
+async function promptYesNo(io, label, defaultValue) {
+    if (!io.prompt) {
+        throw new Error(nonInteractiveSetupMessage());
+    }
+    const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+    const answer = (await io.prompt(`${label} ${suffix}:`)).trim().toLowerCase();
+    if (!answer) {
+        return defaultValue;
+    }
+    if (answer === "y" || answer === "yes" || answer === "true") {
+        return true;
+    }
+    if (answer === "n" || answer === "no" || answer === "false") {
+        return false;
+    }
+    throw new Error(`${label} requires y/yes or n/no`);
 }
 async function exists(path) {
     try {
@@ -293,71 +465,6 @@ function defaultSourceRegistryExample() {
         ""
     ].join("\n");
 }
-async function handleModelCommand(args, io, env) {
-    const [subcommand, ...rest] = args;
-    const flags = parseFlags(rest);
-    if (subcommand === "configure") {
-        await configureModel(flags, io, env);
-        return;
-    }
-    if (subcommand === "status") {
-        const config = readModelRuntimeConfig(env);
-        io.stdout(`Provider: ${config.provider}`);
-        io.stdout(`Model: ${config.model}`);
-        io.stdout(`Credential Ref: ${config.credentialRef ?? "(none)"}`);
-        io.stdout(`Ready: ${config.ready ? "yes" : "no"}`);
-        for (const issue of config.issues) {
-            io.stdout(`- ${issue}`);
-        }
-        for (const credential of statusModelCredentials(env)) {
-            io.stdout(`Credential: ${credential.ref} provider=${credential.provider} type=${credential.type} secret=${credential.secret}`);
-        }
-        return;
-    }
-    if (subcommand === "login") {
-        const config = readModelRuntimeConfig(env);
-        const provider = readProviderFlag(flags.provider ?? config.provider ?? defaultModelConfig().provider);
-        const credentialRef = flags["credential-ref"] ?? config.credentialRef ?? defaultCredentialRef(provider);
-        if (!credentialRef) {
-            throw new Error("model login requires --credential-ref");
-        }
-        await loginModelCredential({ provider, credentialRef, io, env });
-        io.stdout(`Logged in credential: ${credentialRef}`);
-        return;
-    }
-    if (subcommand === "logout") {
-        const config = readModelRuntimeConfig(env);
-        const credentialRef = flags["credential-ref"] ?? rest[0] ?? config.credentialRef;
-        if (!credentialRef) {
-            throw new Error("model logout requires --credential-ref");
-        }
-        logoutModelCredential(credentialRef, env);
-        io.stdout(`Logged out credential: ${credentialRef}`);
-        return;
-    }
-    throw new Error(`Unknown model command: ${subcommand ?? "(missing)"}`);
-}
-async function configureModel(flags, io, env) {
-    const interactive = Object.keys(flags).length === 0;
-    const provider = readProviderFlag(flags.provider ??
-        (interactive ? await promptWithDefault(io, "Provider", defaultModelConfig().provider) : missingFlag("provider")));
-    const model = flags.model ?? (interactive ? await promptWithDefault(io, "Model", defaultModelForProvider(provider)) : missingFlag("model"));
-    const credentialRef = flags["credential-ref"] ??
-        (interactive ? await promptWithDefault(io, "Credential ref", defaultCredentialRef(provider) ?? "") : missingFlag("credential-ref"));
-    const baseUrl = flags["base-url"] ?? (provider === "openai-compatible" && interactive ? await promptWithDefault(io, "Base URL", "") : undefined);
-    const config = {
-        provider,
-        model,
-        credentialRef,
-        ...(baseUrl ? { baseUrl } : {})
-    };
-    writeModelConfig(config, resolveDailyBriefPaths(env).configPath);
-    if (flags["api-key"]) {
-        putCredential(credentialRef, toApiKeyCredential(provider, flags["api-key"]), resolveDailyBriefPaths(env).authPath);
-    }
-    io.stdout(`Model configured: ${provider}/${model}`);
-    io.stdout(`Credential Ref: ${credentialRef}`);
-}
 function parseFlags(args) {
     const flags = {};
     for (let index = 0; index < args.length; index += 1) {
@@ -415,87 +522,44 @@ function defaultCredentialRef(provider) {
         return undefined;
     }
     if (provider === "openai") {
-        return "env:OPENAI_API_KEY";
+        return "openai.default";
     }
     if (provider === "deepseek") {
-        return "env:DEEPSEEK_API_KEY";
+        return "deepseek.default";
     }
     if (provider === "openai-compatible") {
-        return "env:OPENAI_API_KEY";
+        return "openai-compatible.default";
     }
     return defaultModelConfig().credentialRef;
 }
 async function promptWithDefault(io, label, defaultValue) {
     if (!io.prompt) {
-        throw new Error(`model configure requires --${label.toLowerCase().replaceAll(" ", "-")}`);
+        throw new Error(nonInteractiveSetupMessage());
     }
     const answer = await io.prompt(`${label}${defaultValue ? ` (${defaultValue})` : ""}:`);
     return answer.trim() || defaultValue;
 }
-function missingFlag(name) {
-    throw new Error(`model configure requires --${name}`);
-}
 function optionsFromEnv(env) {
     const paths = resolveDailyBriefPaths(env);
-    const discordWebhookUrl = resolveConfiguredWebhookUrl(env);
     return {
+        env,
+        dataHome: paths.dataHome,
+        configPath: paths.configPath,
+        authPath: paths.authPath,
         sourceRegistryPath: paths.sourceRegistryPath,
         sourceItemRoot: paths.sourceItemRoot,
         agentRunRoot: paths.agentRunRoot,
         archiveRoot: paths.briefArchiveRoot,
         modelRuntimeEnv: env,
-        ...(discordWebhookUrl ? { discordWebhookUrl } : {}),
-        ...(env.DAILY_BRIEF_DISCORD_TEMPLATE_PATH ? { discordTemplatePath: env.DAILY_BRIEF_DISCORD_TEMPLATE_PATH } : {})
+        discordEnv: env
     };
 }
-export async function loadDotenvFile(path = ".env", env = process.env) {
-    let contents;
-    try {
-        contents = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === "ENOENT") {
-            return;
-        }
-        throw error;
-    }
-    for (const line of contents.split("\n")) {
-        const entry = parseDotenvLine(line);
-        if (!entry || env[entry.key] !== undefined) {
-            continue;
-        }
-        env[entry.key] = entry.value;
-    }
-}
-function parseDotenvLine(line) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0 || trimmed.startsWith("#")) {
-        return undefined;
-    }
-    const equalsIndex = trimmed.indexOf("=");
-    if (equalsIndex <= 0) {
-        return undefined;
-    }
-    const key = trimmed.slice(0, equalsIndex).trim();
-    const rawValue = trimmed.slice(equalsIndex + 1).trim();
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-        return undefined;
-    }
-    return { key, value: unquoteDotenvValue(rawValue) };
-}
-function unquoteDotenvValue(value) {
-    if (value.length >= 2) {
-        const quote = value[0];
-        const last = value[value.length - 1];
-        if ((quote === "\"" || quote === "'") && last === quote) {
-            return value.slice(1, -1);
-        }
-    }
-    return value;
-}
 function isNodeError(error) {
     return error instanceof Error && "code" in error;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 export async function isCliEntrypoint(argvPath, moduleUrl = import.meta.url) {
     if (!argvPath) {
         return false;
@@ -516,7 +580,6 @@ isCliEntrypoint(process.argv[1])
     if (!isEntrypoint) {
         return false;
     }
-    await loadDotenvFile();
     await runCli(process.argv.slice(2));
     return true;
 })