@aisa-one/cli 0.3.0 → 0.5.0

package/dist/commands/vscode.d.ts

@@ -0,0 +1,65 @@
+import type { LiveServer } from "./mcp.js";
+import type { ConfigResult } from "./llm-config.js";
+/**
+ * VS Code: both of its AI surfaces are plain files in the user profile
+ * directory, so both can be written without the UI.
+ *
+ * - Models: `chatLanguageModels.json` (VS Code ≥ 1.117, the "Custom
+ *   Endpoint" provider). Top level is an array of provider groups; ours is
+ *   one group `{vendor: "customendpoint", name: "AIsa", apiType, models}`.
+ *   Copilot's own models are untouched — the group sits beside them in the
+ *   model picker, so this is always an "add", never a switch. Inline
+ *   completions stay on Copilot; the provider only covers chat and agent.
+ *
+ *   The API key is deliberately NOT written. `apiKey` is a `secret: true`
+ *   property: at run time VS Code treats the value as a reference into its
+ *   own secret storage (`${input:chat.lm.secret.<id>}`), so a literal key
+ *   in the file is never sent (verified on 1.134 — the gateway saw an empty
+ *   bearer and answered 401). The key is entered once in VS Code's Manage
+ *   Models UI, which stores it; there is no command or URI to do that from
+ *   outside, and writing its encrypted store is off the table.
+ * - MCP: `mcp.json` in the same directory, `{servers: {name: {type: "http",
+ *   url, headers}}}`. With a key the entry carries the bearer; without one
+ *   VS Code runs the server's OAuth itself on first use.
+ *
+ * Both writers are key-exact: the AIsa group / `aisa-*` entries are replaced,
+ * anything else in either file is kept byte-for-byte equivalent.
+ */
+export declare const VSCODE_GROUP_NAME = "AIsa";
+/** A representative spread of what the gateway offers, one per lab. */
+export declare const VSCODE_MODELS: Array<{
+    id: string;
+    name: string;
+}>;
+export declare function vscodeUserDir(): string;
+/** Present when VS Code has been run at least once on this machine. */
+export declare function vscodeDetected(): boolean;
+export declare function writeVSCodeLLM(models?: {
+    id: string;
+    name: string;
+}[]): ConfigResult;
+export declare function removeVSCodeLLM(): ConfigResult;
+/** The `code` command: on PATH when the user enabled it, otherwise inside
+ *  the app bundle on macOS or the usual Linux locations. */
+export declare function vscodeBinary(): string | undefined;
+/** The packaged AIsa extension shipped with the CLI. */
+export declare function vscodeExtensionPath(): string;
+/**
+ * The fully automatic route for the key: install the AIsa extension, which
+ * asks VS Code itself to store the key from ~/.aisa/key and add the model
+ * group (see vscode-extension/extension.js). Works on a running VS Code —
+ * new extensions activate without a reload.
+ */
+export declare function installVSCodeExtension(): {
+    ok: true;
+    bin: string;
+} | {
+    ok: false;
+    reason: string;
+};
+/** Open VS Code on a folder (the one connect was launched in). Resolves to
+ *  whether the command could be started; VS Code itself detaches. */
+export declare function launchVSCode(dir: string): boolean;
+export declare function writeVSCodeMCP(chosen: LiveServer[], apiKey: string | undefined): ConfigResult & {
+    written?: number;
+};

package/dist/commands/vscode.js

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { runSync, DEFAULT_TIMEOUT_MS } from "../utils/exec.js";
+import { fileURLToPath } from "node:url";
+import { ensureDir } from "../utils/file.js";
+import { LLM_BASE_URL } from "../constants.js";
+/**
+ * VS Code: both of its AI surfaces are plain files in the user profile
+ * directory, so both can be written without the UI.
+ *
+ * - Models: `chatLanguageModels.json` (VS Code ≥ 1.117, the "Custom
+ *   Endpoint" provider). Top level is an array of provider groups; ours is
+ *   one group `{vendor: "customendpoint", name: "AIsa", apiType, models}`.
+ *   Copilot's own models are untouched — the group sits beside them in the
+ *   model picker, so this is always an "add", never a switch. Inline
+ *   completions stay on Copilot; the provider only covers chat and agent.
+ *
+ *   The API key is deliberately NOT written. `apiKey` is a `secret: true`
+ *   property: at run time VS Code treats the value as a reference into its
+ *   own secret storage (`${input:chat.lm.secret.<id>}`), so a literal key
+ *   in the file is never sent (verified on 1.134 — the gateway saw an empty
+ *   bearer and answered 401). The key is entered once in VS Code's Manage
+ *   Models UI, which stores it; there is no command or URI to do that from
+ *   outside, and writing its encrypted store is off the table.
+ * - MCP: `mcp.json` in the same directory, `{servers: {name: {type: "http",
+ *   url, headers}}}`. With a key the entry carries the bearer; without one
+ *   VS Code runs the server's OAuth itself on first use.
+ *
+ * Both writers are key-exact: the AIsa group / `aisa-*` entries are replaced,
+ * anything else in either file is kept byte-for-byte equivalent.
+ */
+export const VSCODE_GROUP_NAME = "AIsa";
+/** A representative spread of what the gateway offers, one per lab. */
+export const VSCODE_MODELS = [
+    { id: "claude-sonnet-5", name: "Claude Sonnet 5 (AIsa)" },
+    { id: "claude-opus-5", name: "Claude Opus 5 (AIsa)" },
+    { id: "gpt-5.5", name: "GPT-5.5 (AIsa)" },
+    { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro (AIsa)" },
+    { id: "kimi-k3", name: "Kimi K3 (AIsa)" },
+    { id: "glm-5.2", name: "GLM-5.2 (AIsa)" },
+    { id: "qwen3.7-max", name: "Qwen3.7 Max (AIsa)" },
+];
+export function vscodeUserDir() {
+    const home = homedir();
+    if (process.platform === "darwin")
+        return join(home, "Library", "Application Support", "Code", "User");
+    if (process.platform === "win32")
+        return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), "Code", "User");
+    return join(home, ".config", "Code", "User");
+}
+/** Present when VS Code has been run at least once on this machine. */
+export function vscodeDetected() {
+    return existsSync(vscodeUserDir());
+}
+function readJson(path) {
+    if (!existsSync(path))
+        return undefined;
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function writeVSCodeLLM(models = VSCODE_MODELS) {
+    const dir = vscodeUserDir();
+    const path = join(dir, "chatLanguageModels.json");
+    let groups;
+    try {
+        groups = readJson(path) ?? [];
+    }
+    catch {
+        return { ok: false, reason: `${path} exists but is not valid JSON` };
+    }
+    if (!Array.isArray(groups))
+        return { ok: false, reason: `${path} is not the expected array` };
+    const ours = {
+        vendor: "customendpoint",
+        name: VSCODE_GROUP_NAME,
+        apiType: "chat-completions",
+        models: models.map((m) => ({
+            id: m.id,
+            name: m.name,
+            url: `${LLM_BASE_URL}/v1`,
+            toolCalling: true,
+            vision: false,
+            maxInputTokens: 200_000,
+            maxOutputTokens: 32_000,
+        })),
+    };
+    const isOurs = (g) => typeof g === "object" && g !== null && g.vendor === "customendpoint" &&
+        g.name === VSCODE_GROUP_NAME;
+    // A key reference VS Code already stored for our group survives the
+    // rewrite — the user should paste it once, not once per run.
+    const prior = groups.find(isOurs);
+    const next = groups.filter((g) => !isOurs(g));
+    next.push(typeof prior?.apiKey === "string" && prior.apiKey.startsWith("${input:") ? { ...ours, apiKey: prior.apiKey } : ours);
+    ensureDir(dir);
+    writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+    return { ok: true, path };
+}
+export function removeVSCodeLLM() {
+    const path = join(vscodeUserDir(), "chatLanguageModels.json");
+    const groups = readJson(path);
+    if (!Array.isArray(groups))
+        return { ok: true, path };
+    const next = groups.filter((g) => !(typeof g === "object" && g !== null && g.name === VSCODE_GROUP_NAME));
+    writeFileSync(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+    return { ok: true, path };
+}
+/** The `code` command: on PATH when the user enabled it, otherwise inside
+ *  the app bundle on macOS or the usual Linux locations. */
+export function vscodeBinary() {
+    const candidates = process.platform === "darwin"
+        ? ["code", "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+            join(homedir(), "Applications/Visual Studio Code.app/Contents/Resources/app/bin/code")]
+        : ["code", "/usr/bin/code", "/usr/share/code/bin/code", "/snap/bin/code"];
+    for (const c of candidates) {
+        const r = runSync(c, ["--version"]);
+        if (r.status === 0)
+            return c;
+    }
+    return undefined;
+}
+/** The packaged AIsa extension shipped with the CLI. */
+export function vscodeExtensionPath() {
+    return fileURLToPath(new URL("../../vscode-extension/aisa-vscode.vsix", import.meta.url));
+}
+/**
+ * The fully automatic route for the key: install the AIsa extension, which
+ * asks VS Code itself to store the key from ~/.aisa/key and add the model
+ * group (see vscode-extension/extension.js). Works on a running VS Code —
+ * new extensions activate without a reload.
+ */
+export function installVSCodeExtension() {
+    const bin = vscodeBinary();
+    if (!bin)
+        return { ok: false, reason: "the code command was not found" };
+    const vsix = vscodeExtensionPath();
+    if (!existsSync(vsix))
+        return { ok: false, reason: `extension package missing at ${vsix}` };
+    const r = runSync(bin, ["--install-extension", vsix, "--force"], { timeout: DEFAULT_TIMEOUT_MS });
+    if (r.status !== 0)
+        return { ok: false, reason: (r.stderr || r.stdout || `exit ${r.status}`).trim().split("\n")[0] };
+    return { ok: true, bin };
+}
+/** Open VS Code on a folder (the one connect was launched in). Resolves to
+ *  whether the command could be started; VS Code itself detaches. */
+export function launchVSCode(dir) {
+    const bin = vscodeBinary();
+    if (!bin)
+        return false;
+    const r = runSync(bin, [dir], { timeout: 30_000 });
+    return r.status === 0;
+}
+export function writeVSCodeMCP(chosen, apiKey) {
+    const dir = vscodeUserDir();
+    const path = join(dir, "mcp.json");
+    let doc;
+    try {
+        const raw = readJson(path);
+        doc = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    }
+    catch {
+        return { ok: false, reason: `${path} exists but is not valid JSON` };
+    }
+    const servers = (doc.servers ?? {});
+    for (const s of chosen) {
+        servers[`aisa-${s.slug}`] = apiKey
+            ? { type: "http", url: s.endpoint, headers: { Authorization: `Bearer ${apiKey}` } }
+            : { type: "http", url: s.endpoint };
+    }
+    doc.servers = servers;
+    ensureDir(dir);
+    writeFileSync(path, JSON.stringify(doc, null, 2) + "\n", "utf-8");
+    return { ok: true, path, written: chosen.length };
+}

package/dist/commands/wrappers.d.ts

@@ -0,0 +1,23 @@
+import type { ModelChoice } from "./llm-config.js";
+export declare const CLAUDE_AISA_SETTINGS: () => string;
+/** The --settings document claude-aisa loads: gateway env + model tiers. */
+export declare function writeClaudeAisaSettings(apiKey: string, models: ModelChoice): string;
+/**
+ * Where wrappers go: npm's global bin first — on this platform it is the
+ * directory the agents themselves live in, so it is on PATH by definition.
+ * ~/.local/bin is the fallback (standard on Linux, needs one PATH line on
+ * macOS — reported to the caller, never written into anyone's shell rc).
+ */
+export declare function wrapperBinDir(): {
+    dir: string;
+    onPath: boolean;
+};
+export type WrapperResult = {
+    ok: boolean;
+    dir: string;
+    wrote: string[];
+    /** Set when the chosen dir is not on PATH — the one line the user can add. */
+    pathHint?: string;
+};
+/** Write one or both wrappers, idempotently. */
+export declare function installWrappers(which: Array<"claude-aisa" | "codex-aisa">): WrapperResult;

package/dist/commands/wrappers.js

@@ -0,0 +1,102 @@
+import { runSync, QUICK_TIMEOUT_MS } from "../utils/exec.js";
+import { accessSync, chmodSync, constants, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { LLM_BASE_URL } from "../constants.js";
+/**
+ * The claude-aisa / codex-aisa companion commands: run the agent the user
+ * already has, on AIsa, without touching a byte of their own configuration.
+ *
+ * Verified mechanics (2026-08-22, three loopback experiments):
+ *  - Claude Code's settings.json env OVERRIDES real environment variables,
+ *    so an env-prefix wrapper cannot work — but `--settings <file>` overrides
+ *    everything, and it is the same flag Sapiom runs its whole product on.
+ *    claude-aisa therefore points --settings at a file under ~/.aisa.
+ *  - Codex has native profiles: codex-aisa is just `--profile aisa`, whose
+ *    definition lives in ~/.codex/config.toml (profiles cannot be external).
+ *
+ * The wrappers contain no credentials. Claude's key sits in the settings
+ * file (same directory and permissions as the key itself); Codex's sits in
+ * its provider entry. Removing a wrapper is deleting one small file.
+ */
+const aisaDir = () => join(homedir(), ".aisa");
+export const CLAUDE_AISA_SETTINGS = () => join(aisaDir(), "claude-aisa.settings.json");
+/** The --settings document claude-aisa loads: gateway env + model tiers. */
+export function writeClaudeAisaSettings(apiKey, models) {
+    mkdirSync(aisaDir(), { recursive: true });
+    const path = CLAUDE_AISA_SETTINGS();
+    const doc = {
+        env: {
+            ANTHROPIC_BASE_URL: LLM_BASE_URL,
+            ANTHROPIC_AUTH_TOKEN: apiKey,
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: models.smallModel,
+            ANTHROPIC_DEFAULT_SONNET_MODEL: models.model,
+            ANTHROPIC_DEFAULT_OPUS_MODEL: models.model,
+        },
+    };
+    writeFileSync(path, JSON.stringify(doc, null, 2) + "\n", { mode: 0o600 });
+    chmodSync(path, 0o600);
+    return path;
+}
+/**
+ * Where wrappers go: npm's global bin first — on this platform it is the
+ * directory the agents themselves live in, so it is on PATH by definition.
+ * ~/.local/bin is the fallback (standard on Linux, needs one PATH line on
+ * macOS — reported to the caller, never written into anyone's shell rc).
+ */
+export function wrapperBinDir() {
+    let dir;
+    try {
+        const r = runSync("npm", ["config", "get", "prefix"], { timeout: QUICK_TIMEOUT_MS });
+        const prefix = r.status === 0 ? r.stdout.trim() : "";
+        if (prefix && existsSync(join(prefix, "bin"))) {
+            accessSync(join(prefix, "bin"), constants.W_OK);
+            dir = join(prefix, "bin");
+        }
+    }
+    catch {
+        /* fall through to ~/.local/bin */
+    }
+    if (!dir) {
+        dir = join(homedir(), ".local", "bin");
+        mkdirSync(dir, { recursive: true });
+    }
+    const onPath = (process.env.PATH ?? "").split(":").includes(dir);
+    return { dir, onPath };
+}
+/** Write one or both wrappers, idempotently. */
+export function installWrappers(which) {
+    const { dir, onPath } = wrapperBinDir();
+    const scripts = {
+        "claude-aisa": `#!/bin/sh
+# AIsa companion for Claude Code. Your own claude setup is untouched:
+# this one session loads AIsa's settings via --settings and nothing else.
+exec claude --settings "$HOME/.aisa/claude-aisa.settings.json" "$@"
+`,
+        "codex-aisa": `#!/bin/sh
+# AIsa companion for Codex: your default setup stays as it is; this runs
+# the aisa profile defined in ~/.codex/config.toml for this session only.
+exec codex --profile aisa "$@"
+`,
+    };
+    const wrote = [];
+    try {
+        for (const name of which) {
+            const p = join(dir, name);
+            writeFileSync(p, scripts[name], { mode: 0o755 });
+            chmodSync(p, 0o755);
+            wrote.push(name);
+        }
+    }
+    catch {
+        return { ok: false, dir, wrote };
+    }
+    return {
+        ok: true,
+        dir,
+        wrote,
+        ...(onPath
+            ? {}
+            : { pathHint: `echo 'export PATH="${dir}:$PATH"' >> ~/.zshrc && source ~/.zshrc` }),
+    };
+}

package/dist/completion.js

@@ -1,6 +1,6 @@
 import { readCache } from "./cache.js";
 import { cacheScope } from "./api.js";
-import { AGENT_DIRS, API_CATEGORIES, COINGECKO_IDS, MCP_CONFIGS, MEDIA_TYPES, VIDEO_MODELS, } from "./constants.js";
+import { AGENT_DIRS, API_CATEGORIES, MCP_CONFIGS } from "./constants.js";
 const SHELLS = ["bash", "zsh", "fish"];
 export function isShell(value) {
     return SHELLS.includes(value);
@@ -9,46 +9,12 @@ export function isShell(value) {
 function cachedProviders() {
     return readCache(`catalog/${cacheScope()}/category.json`)?.data.apis || [];
 }
-/**
- * Slugs usable with `aisa run`. A provider's id is not always its URL slug
- * (`brave-search` serves `/apis/v1/brave/...`), so prefer the real slug from any
- * cached detail and fall back to the id.
- */
-function runSlugs() {
-    const out = new Map();
-    for (const provider of cachedProviders()) {
-        const detail = readCache(`catalog/${cacheScope()}/${provider.id.replace(/[^\w.-]/g, "_")}.json`)?.data.api;
-        const first = detail?.endpoint_groups?.flatMap((g) => g.endpoints || [])[0];
-        const slug = first
-            ? first.path.replace(/^\/apis\/v1\//, "").split("/")[0]
-            : provider.id;
-        out.set(slug, `${provider.endpoint_count} endpoints`);
-    }
-    return [...out].map(([value, description]) => ({ value, description }));
-}
 function providerIds() {
     return cachedProviders().map((p) => ({
         value: p.id,
         description: `${p.endpoint_count} endpoints`,
     }));
 }
-/** Endpoint paths within one provider, for `aisa run <slug> <TAB>`. */
-function endpointPaths(slug) {
-    for (const provider of cachedProviders()) {
-        const detail = readCache(`catalog/${cacheScope()}/${provider.id.replace(/[^\w.-]/g, "_")}.json`)?.data.api;
-        if (!detail)
-            continue;
-        const endpoints = (detail.endpoint_groups || []).flatMap((g) => g.endpoints || []);
-        const matching = endpoints.filter((e) => e.path.replace(/^\/apis\/v1\//, "").startsWith(`${slug}/`));
-        if (matching.length > 0) {
-            return matching.map((e) => ({
-                value: `/${e.path.replace(/^\/apis\/v1\//, "").split("/").slice(1).join("/")}`,
-                description: e.name,
-            }));
-        }
-    }
-    return [];
-}
 function skillSlugs() {
     const index = readCache("skills/tree.json")?.data;
     if (!index)
@@ -73,38 +39,10 @@ function modelIds() {
 const STATIC = {
     agent: Object.keys(AGENT_DIRS).concat("all").map((value) => ({ value })),
     mcpAgent: Object.keys(MCP_CONFIGS).concat("all").map((value) => ({ value })),
-    lang: ["curl", "python", "node", "typescript"].map((value) => ({ value })),
-    searchType: [
-        { value: "tavily" },
-        { value: "youtube" },
-        { value: "scholar" },
-        { value: "smart", description: "currently degraded" },
-        { value: "full", description: "currently degraded" },
-    ],
-    stockField: [
-        "info",
-        "estimates",
-        "financials",
-        "filings",
-        "insider",
-        "institutional",
-        "news",
-    ].map((value) => ({ value })),
-    configKey: ["defaultModel", "baseUrl", "outputFormat", "twitterCookies", "twitterProxy"].map((value) => ({ value })),
+    configKey: ["defaultModel", "baseUrl", "routerUrl", "outputFormat"].map((value) => ({ value })),
     template: ["default", "llm", "search", "finance", "twitter", "video"].map((value) => ({ value })),
-    videoModel: Object.entries(VIDEO_MODELS).map(([value, spec]) => ({
-        value,
-        description: spec.requiresMedia ? `needs --media ${spec.requiresMedia}` : undefined,
-    })),
-    mediaType: MEDIA_TYPES.map((value) => ({ value: `${value}=` })),
     apiCategory: API_CATEGORIES.map((value) => ({ value })),
-    period: ["current", "1d", "7d", "30d", "90d", "1y"].map((value) => ({ value })),
-    cryptoSource: ["coingecko", "financial"].map((value) => ({ value })),
     shell: SHELLS.map((value) => ({ value })),
-    crypto: Object.keys(COINGECKO_IDS).map((value) => ({
-        value: value.toUpperCase(),
-        description: COINGECKO_IDS[value],
-    })),
 };
 /**
  * Values for an option that takes an argument, keyed by "command path --option".
@@ -117,36 +55,21 @@ const OPTION_VALUES = [
     ["skills list --category", () => skillCategories()],
     ["skills init --template", () => STATIC.template],
     ["api list --category", () => STATIC.apiCategory],
-    ["api search --provider", () => providerIds()],
-    ["api code --lang", () => STATIC.lang],
-    ["code --lang", () => STATIC.lang],
-    ["video create --model", () => STATIC.videoModel],
-    ["video create --media", () => STATIC.mediaType],
     ["chat --model", () => modelIds()],
-    ["web-search --type", () => STATIC.searchType],
-    ["stock --field", () => STATIC.stockField],
-    ["crypto --period", () => STATIC.period],
-    ["crypto --source", () => STATIC.cryptoSource],
     ["models --provider", () => [...new Set(modelIds().map((m) => m.description))].filter(Boolean).map((value) => ({ value: value }))],
 ];
 /**
  * Positional-argument candidates, keyed by command path and argument index.
  * Callbacks receive the positionals parsed so far — never the raw word list,
  * whose last entry may be an option or an option's value
- * (`run financial --raw <TAB>`).
+ * (`api show financial --json <TAB>`).
  */
 const POSITIONAL = [
-    ["run", 0, () => runSlugs()],
-    ["run", 1, (positionals) => endpointPaths(positionals[0])],
     ["api show", 0, () => providerIds()],
-    ["api code", 0, () => runSlugs()],
-    ["api code", 1, (positionals) => endpointPaths(positionals[0])],
-    ["code", 0, () => runSlugs()],
     ["models show", 0, () => modelIds()],
     ["skills show", 0, () => skillSlugs()],
     ["skills install", 0, () => skillSlugs()],
     ["skills remove", 0, () => skillSlugs()],
-    ["crypto", 0, () => STATIC.crypto],
     ["config set", 0, () => STATIC.configKey],
     ["config get", 0, () => STATIC.configKey],
     ["completion", 0, () => STATIC.shell],

package/dist/config.js

@@ -1,22 +1,88 @@
 import Conf from "conf";
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { ENV_VAR_NAME } from "./constants.js";
+// ~/.aisa is the credential home: one visible, portable, platform-stable
+// place for the key, next door to ~/.claude and ~/.codex. The conf store
+// (platform-specific path, invisible to other tools) remains a legacy read
+// source and a sync target so older CLI versions keep working.
+const aisaDir = () => join(homedir(), ".aisa");
+const keyFile = () => join(aisaDir(), "key");
+function readKeyFile() {
+    try {
+        const k = readFileSync(keyFile(), "utf-8").trim();
+        return k || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeKeyFile(key) {
+    mkdirSync(aisaDir(), { recursive: true });
+    writeFileSync(keyFile(), key + "\n", { mode: 0o600 });
+    chmodSync(keyFile(), 0o600);
+}
+/**
+ * 0600, because this file holds credentials.
+ *
+ * conf defaults to 0o666 (0644 after a typical umask), so until 2026-08-24
+ * every install left the API key — and the Twitter session cookies, which are
+ * account access rather than something revocable — world-readable on shared
+ * machines. The key file next door was already 0600; this closes the gap on
+ * the store that mirrors it.
+ *
+ * The mirror itself stays: published CLIs up to 0.3.0 know nothing about
+ * ~/.aisa/key and read the key only from here, so dropping the write would
+ * silently log out anyone still running one alongside a newer copy.
+ */
+const CONFIG_FILE_MODE = 0o600;
 const config = new Conf({
     projectName: "aisa-cli",
+    configFileMode: CONFIG_FILE_MODE,
     schema: {
         apiKey: { type: "string", default: "" },
         defaultModel: { type: "string", default: "gpt-4.1-mini" },
         baseUrl: { type: "string", default: "https://api.aisa.one/v1" },
+        routerUrl: { type: "string", default: "" },
         outputFormat: { type: "string", default: "text" },
+        // Set by --lang or the page's picker; read by both renderers so they
+        // never end up in different languages.
+        lang: { type: "string", default: "" },
         twitterCookies: { type: "string", default: "" },
         twitterProxy: { type: "string", default: "" },
     },
 });
+// configFileMode only applies when conf writes. Every install that ran before
+// this change already has the file on disk at 0644, and a user who never logs
+// in again would keep it — so tighten what is already there, once, at startup.
+// Best-effort: a config we cannot chmod is still a config we can read.
+try {
+    chmodSync(config.path, CONFIG_FILE_MODE);
+}
+catch {
+    /* not ours to chmod, or gone — neither is worth failing a command over */
+}
 export function getApiKey() {
     const envKey = process.env[ENV_VAR_NAME];
     if (envKey)
         return envKey;
+    const fileKey = readKeyFile();
+    if (fileKey)
+        return fileKey;
     const stored = config.get("apiKey");
-    return stored || undefined;
+    if (stored) {
+        // Legacy location — migrate on first read so every other tool (wrappers,
+        // scripts) finds the key at the one agreed place from now on.
+        try {
+            writeKeyFile(stored);
+        }
+        catch {
+            /* migration is best-effort; the key itself is still returned */
+        }
+        return stored;
+    }
+    return undefined;
 }
 export function requireApiKey() {
     const key = getApiKey();
@@ -27,15 +93,23 @@ export function requireApiKey() {
     return key;
 }
 export function setApiKey(key) {
+    writeKeyFile(key);
     config.set("apiKey", key);
 }
 export function clearApiKey() {
+    try {
+        if (existsSync(keyFile()))
+            unlinkSync(keyFile());
+    }
+    catch {
+        /* the conf delete below still applies */
+    }
     config.delete("apiKey");
 }
 export function getKeySource() {
     if (process.env[ENV_VAR_NAME])
         return "env";
-    if (config.get("apiKey"))
+    if (readKeyFile() || config.get("apiKey"))
         return "config";
     return "none";
 }