@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/dist/commands/whoami.js

@@ -0,0 +1,52 @@
+import { PROVIDERS, getProvider } from "../providers/index.js";
+import { listCredentials, listLegacy, maskKey, resolveApiKey } from "../config/store.js";
+export const whoamiCommand = {
+    name: "whoami",
+    description: "Show which provider/model keys are configured.",
+    run({ state }) {
+        const lines = ["Authentication status:", `  current scope: ${state.providerId} · ${state.model}`];
+        const current = getProvider(state.providerId);
+        if (current)
+            lines.push("  " + describeLookup(current, resolveApiKey(current.id, state.model, current.authEnv)));
+        const credentials = listCredentials();
+        lines.push("");
+        lines.push(`Stored keys (${credentials.length}, provider-wide):`);
+        if (credentials.length === 0)
+            lines.push("  (none) — add one with /login");
+        for (const c of credentials) {
+            const marker = c.provider === state.providerId ? "● " : "  ";
+            const origin = c.model ? `   (originally saved for ${c.model})` : "";
+            lines.push(`${marker}${c.provider}   ${maskKey(c.key)}${origin}`);
+        }
+        const legacy = listLegacy();
+        if (legacy.length > 0) {
+            lines.push("");
+            lines.push("Legacy keys (could not be migrated — re-save with /login):");
+            for (const l of legacy)
+                lines.push(`  ${l.provider}   ${maskKey(l.key)}`);
+        }
+        const envLines = [];
+        for (const p of PROVIDERS) {
+            const envVar = p.authEnv.find((v) => process.env[v]);
+            if (envVar)
+                envLines.push(`  ${envVar}   (${p.id}, any model)`);
+        }
+        if (envLines.length > 0) {
+            lines.push("");
+            lines.push("Environment keys:");
+            lines.push(...envLines);
+        }
+        return { message: lines.join("\n") };
+    },
+};
+function describeLookup(provider, lookup) {
+    if (provider.authEnv.length === 0)
+        return `${provider.id}: no key needed`;
+    if (lookup.status === "ok")
+        return lookup.source === "env"
+            ? `${provider.id}: env ${lookup.envVar}`
+            : `${provider.id}: stored ${maskKey(lookup.key)}`;
+    if (lookup.status === "unbound")
+        return `${provider.id}: NO bound key (a stored legacy key needs re-binding)`;
+    return `${provider.id}: no key — /login ${provider.id} <model> <key>`;
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function getPaths(): any;
+export declare function ensureDir(dir: any): void;
+/** Tighten permissions on a file storing secrets where the OS supports it. */
+export declare function lockdown(file: any): void;

package/dist/config/paths.js

@@ -0,0 +1,59 @@
+/**
+ * Filesystem layout for FastCode user data.
+ *
+ *   ~/.fastcode/
+ *     config.json       global preferences (provider, model, theme, …)
+ *     auth.json         per-provider API keys (mode 0600)
+ *     skills/           installed SKILL.md folders
+ *     plugins/          installed plugin folders
+ *     cache/            transient downloads & registry caches
+ *     sessions/         conversation transcripts (future)
+ *     logs/             debug logs (future)
+ *
+ * On Windows we keep using `~/.fastcode` rather than %APPDATA% to match the
+ * dotfile convention most TUIs use; users can override via $FASTCODE_HOME.
+ */
+import { join } from "node:path";
+import { mkdirSync, existsSync, chmodSync } from "node:fs";
+import { safeHome, isWindows } from "../lib/platform.js";
+let cached;
+export function getPaths() {
+    if (cached)
+        return cached;
+    const root = process.env["FASTCODE_HOME"] ?? join(safeHome(), ".fastcode");
+    const paths = {
+        root,
+        config: join(root, "config.json"),
+        auth: join(root, "auth.json"),
+        trust: join(root, "trusted.json"),
+        skills: join(root, "skills"),
+        plugins: join(root, "plugins"),
+        cache: join(root, "cache"),
+        sessions: join(root, "sessions"),
+        logs: join(root, "logs"),
+    };
+    ensureDir(paths.root);
+    ensureDir(paths.skills);
+    ensureDir(paths.plugins);
+    ensureDir(paths.cache);
+    ensureDir(paths.sessions);
+    ensureDir(paths.logs);
+    cached = paths;
+    return paths;
+}
+export function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+/** Tighten permissions on a file storing secrets where the OS supports it. */
+export function lockdown(file) {
+    if (isWindows())
+        return;
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        // best effort; some filesystems (FAT, Termux on internal storage) don't
+        // honor chmod and that's fine.
+    }
+}

package/dist/config/store.d.ts

@@ -0,0 +1,89 @@
+export declare const DEFAULT_CONFIG: {
+    providerId: string;
+    model: string;
+    theme: string;
+    agentMode: boolean;
+    systemPrompt: string;
+    enabledSkills: any[];
+    enabledPlugins: any[];
+    skillsRegistry: string;
+    lifetimeCostUsd: number;
+    /**
+     * Extra directories the file tools may read and write outside the project
+     * root. Relative entries are resolved against the project root; `~/` is
+     * expanded against the user's home directory.
+     */
+    sharedDirs: any[];
+    /** Maximum agent tool turns before the loop asks the user to continue. */
+    maxAgentTurns: number;
+    /** Abort a stream that receives no data for this long (ms). */
+    requestIdleTimeoutMs: number;
+    /** Approximate character budget before history compaction kicks in. */
+    contextBudgetChars: number;
+    /** Thinking depth: auto = send nothing, provider default. */
+    reasoningEffort: string;
+    /** Cached per-provider/model capabilities (native vs pseudo tool calling). */
+    capabilities: {
+        toolCalling: {};
+    };
+};
+export interface StoredCredential {
+    provider: string;
+    /** Model the key was originally saved for (display only; keys are provider-wide). */
+    model?: string;
+    key: string;
+    addedAt: string;
+}
+export interface AuthStore {
+    version: number;
+    /** Provider-scoped credentials, keyed by provider id. */
+    keys: Record<string, StoredCredential>;
+    /** Old provider-only keys that could not be migrated (kept for diagnostics). */
+    legacy: Record<string, string>;
+}
+export declare const AUTH_VERSION = 3;
+export type KeyLookup = {
+    status: "ok";
+    key: string;
+    source: "file" | "env";
+    envVar?: string;
+} | {
+    status: "unbound";
+    provider: string;
+    legacyKey: string;
+} | {
+    status: "missing";
+};
+export declare function loadConfig(): any;
+export declare function saveConfig(cfg: any): void;
+/** Composite id used by the legacy v2 format; kept for API compatibility. */
+export declare function scopeId(providerId: any, model: any): string;
+export declare function loadAuth(): AuthStore;
+export declare function saveAuth(store: AuthStore): void;
+export declare function getCredential(providerId: any, _model?: any): StoredCredential | undefined;
+export declare function listCredentials(): StoredCredential[];
+export declare function listLegacy(): Array<{
+    provider: string;
+    key: string;
+}>;
+export declare function getLegacy(providerId: any): string | undefined;
+/** Save/replace the provider-wide credential (drops any legacy key). */
+export declare function setCredential(providerId: any, model: any, key: any): StoredCredential;
+export declare function removeCredential(providerId: any, _model?: any): boolean;
+/** Remove the provider-wide credential plus any legacy leftovers. */
+export declare function removeCredentialsForProvider(providerId: any): number;
+/** Turn a key into a safe terminal echo: `sk-****abcd`. */
+export declare function maskKey(key: any): string;
+/**
+ * Resolve the key to use for a provider:
+ *   1. the provider-wide credential in auth.json,
+ *   2. the provider's environment variable (provider-scoped, any model), and
+ *   3. a legacy provider-only key that somehow escaped migration.
+ */
+export declare function resolveApiKey(providerId: any, _model: any, envVars: any): KeyLookup;
+/** Best-effort key for a provider regardless of model (used to list models). */
+export declare function resolveProviderKey(providerId: any, envVars: any): {
+    key?: string;
+    source?: "file" | "env";
+    envVar?: string;
+};

package/dist/config/store.js

@@ -0,0 +1,260 @@
+/**
+ * Persistent config & auth store.
+ *
+ * We deliberately keep the format human-readable JSON so users on Termux can
+ * edit it from `nano ~/.fastcode/config.json` if needed. Atomic writes prevent
+ * partial files on Ctrl+C.
+ *
+ * API keys are scoped to a provider, not to a model. auth.json stores one
+ * credential per provider id, so switching between models of the same provider
+ * reuses the same key. The old "provider::model" (v2) and provider-only (v1)
+ * formats are read and migrated to the provider-scoped v3 layout on first load.
+ */
+import { readFileSync, writeFileSync, existsSync, renameSync, copyFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { getPaths, lockdown, ensureDir } from "./paths.js";
+import { DEFAULT_THEME } from "./themes.js";
+export const DEFAULT_CONFIG = {
+    providerId: "anthropic",
+    model: "claude-sonnet-5.5",
+    theme: DEFAULT_THEME,
+    agentMode: true,
+    systemPrompt: "You are FastCode, a fast, friendly coding assistant in a terminal UI. " +
+        "Prefer concise responses. Use markdown when helpful (especially fenced " +
+        "code blocks). When the user asks for code changes, output complete files " +
+        "or unified diffs the user can apply.",
+    enabledSkills: [],
+    enabledPlugins: [],
+    skillsRegistry: "https://skillshub.wtf",
+    lifetimeCostUsd: 0,
+    /**
+     * Extra directories the file tools may read and write outside the project
+     * root. Relative entries are resolved against the project root; `~/` is
+     * expanded against the user's home directory.
+     */
+    sharedDirs: [],
+    /** Maximum agent tool turns before the loop asks the user to continue. */
+    maxAgentTurns: 24,
+    /** Abort a stream that receives no data for this long (ms). */
+    requestIdleTimeoutMs: 60_000,
+    /** Approximate character budget before history compaction kicks in. */
+    contextBudgetChars: 400_000,
+    /** Thinking depth: auto = send nothing, provider default. */
+    reasoningEffort: "auto",
+    /** Cached per-provider/model capabilities (native vs pseudo tool calling). */
+    capabilities: {
+        toolCalling: {},
+    },
+};
+export const AUTH_VERSION = 3;
+export function loadConfig() {
+    const { config } = getPaths();
+    if (!existsSync(config))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const raw = JSON.parse(readFileSync(config, "utf8"));
+        return { ...DEFAULT_CONFIG, ...raw };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(cfg) {
+    const { config } = getPaths();
+    atomicWrite(config, JSON.stringify(cfg, null, 2));
+}
+/** Composite id used by the legacy v2 format; kept for API compatibility. */
+export function scopeId(providerId, model) {
+    return `${providerId}::${model}`;
+}
+/** Pick the most recently saved credential when several legacy scopes map to one provider. */
+function keepNewest(keys, credential) {
+    const existing = keys[credential.provider];
+    if (!existing) {
+        keys[credential.provider] = credential;
+        return;
+    }
+    const previous = Date.parse(existing.addedAt || "") || 0;
+    const next = Date.parse(credential.addedAt || "") || 0;
+    if (next > previous)
+        keys[credential.provider] = credential;
+}
+let migrationChecked = false;
+export function loadAuth() {
+    const { auth } = getPaths();
+    const empty = { version: AUTH_VERSION, keys: {}, legacy: {} };
+    if (!existsSync(auth))
+        return empty;
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(auth, "utf8"));
+    }
+    catch {
+        return empty;
+    }
+    if (!raw || typeof raw !== "object")
+        return empty;
+    const keys = {};
+    const legacy = {};
+    let migrated = false;
+    const source = raw.keys && typeof raw.keys === "object" ? raw.keys : {};
+    for (const [id, value] of Object.entries(source)) {
+        if (value && typeof value === "object" && typeof value.key === "string" && value.key.trim()) {
+            const [idProvider, idModel] = id.split("::");
+            const provider = typeof value.provider === "string" && value.provider ? value.provider : idProvider || id;
+            const model = typeof value.model === "string" ? value.model : idModel || "";
+            if (id.includes("::") || raw.version !== AUTH_VERSION)
+                migrated = true;
+            keepNewest(keys, {
+                provider,
+                model,
+                key: value.key,
+                addedAt: typeof value.addedAt === "string" ? value.addedAt : "",
+            });
+        }
+        else if (typeof value === "string" && value.trim()) {
+            // v1: keys were plain provider -> key strings.
+            keepNewest(keys, { provider: id, key: value, addedAt: "" });
+            migrated = true;
+        }
+    }
+    if (raw.legacy && typeof raw.legacy === "object") {
+        for (const [provider, value] of Object.entries(raw.legacy)) {
+            if (typeof value === "string" && value.trim()) {
+                // Provider-only keys are exactly what v3 wants: migrate instead
+                // of leaving them unusable.
+                keepNewest(keys, { provider, key: value, addedAt: "" });
+                migrated = true;
+            }
+        }
+    }
+    if (migrated && !migrationChecked) {
+        try {
+            // Keep the pre-migration file so a user with several old model
+            // keys can recover a credential we had to collapse.
+            const backup = auth + ".v2.bak";
+            if (!existsSync(backup))
+                copyFileSync(auth, backup);
+            writeAuth({ version: AUTH_VERSION, keys, legacy });
+        }
+        catch {
+            // Read-only home (or locked file): keep the migrated view in memory.
+        }
+    }
+    migrationChecked = true;
+    return { version: AUTH_VERSION, keys, legacy };
+}
+function writeAuth(store) {
+    const { auth } = getPaths();
+    atomicWrite(auth, JSON.stringify({ version: AUTH_VERSION, keys: store.keys }, null, 2));
+    lockdown(auth);
+}
+export function saveAuth(store) {
+    writeAuth(store);
+}
+export function getCredential(providerId, _model) {
+    return loadAuth().keys[providerId];
+}
+export function listCredentials() {
+    return Object.values(loadAuth().keys);
+}
+export function listLegacy() {
+    return Object.entries(loadAuth().legacy).map(([provider, key]) => ({ provider, key }));
+}
+export function getLegacy(providerId) {
+    return loadAuth().legacy[providerId];
+}
+/** Save/replace the provider-wide credential (drops any legacy key). */
+export function setCredential(providerId, model, key) {
+    const store = loadAuth();
+    const credential = {
+        provider: providerId,
+        model,
+        key: key.trim(),
+        addedAt: new Date().toISOString(),
+    };
+    store.keys[providerId] = credential;
+    delete store.legacy[providerId];
+    saveAuth(store);
+    return credential;
+}
+export function removeCredential(providerId, _model) {
+    const store = loadAuth();
+    if (!store.keys[providerId])
+        return false;
+    delete store.keys[providerId];
+    saveAuth(store);
+    return true;
+}
+/** Remove the provider-wide credential plus any legacy leftovers. */
+export function removeCredentialsForProvider(providerId) {
+    const store = loadAuth();
+    let removed = 0;
+    if (store.keys[providerId]) {
+        delete store.keys[providerId];
+        removed += 1;
+    }
+    if (store.legacy[providerId]) {
+        delete store.legacy[providerId];
+        removed += 1;
+    }
+    if (removed > 0)
+        saveAuth(store);
+    return removed;
+}
+/** Turn a key into a safe terminal echo: `sk-****abcd`. */
+export function maskKey(key) {
+    const value = (key ?? "").trim();
+    if (!value)
+        return "";
+    if (value.length <= 8)
+        return "*".repeat(value.length);
+    return value.slice(0, 3) + "****" + value.slice(-4);
+}
+/**
+ * Resolve the key to use for a provider:
+ *   1. the provider-wide credential in auth.json,
+ *   2. the provider's environment variable (provider-scoped, any model), and
+ *   3. a legacy provider-only key that somehow escaped migration.
+ */
+export function resolveApiKey(providerId, _model, envVars) {
+    const store = loadAuth();
+    const credential = store.keys[providerId];
+    if (credential && credential.key)
+        return { status: "ok", key: credential.key, source: "file" };
+    for (const envVar of envVars ?? []) {
+        const value = process.env[envVar];
+        if (value && value.trim())
+            return { status: "ok", key: value.trim(), source: "env", envVar };
+    }
+    if (store.legacy[providerId])
+        return { status: "unbound", provider: providerId, legacyKey: store.legacy[providerId] };
+    return { status: "missing" };
+}
+/** Best-effort key for a provider regardless of model (used to list models). */
+export function resolveProviderKey(providerId, envVars) {
+    const store = loadAuth();
+    const credential = store.keys[providerId];
+    if (credential && credential.key)
+        return { key: credential.key, source: "file" };
+    for (const envVar of envVars ?? []) {
+        const value = process.env[envVar];
+        if (value && value.trim())
+            return { key: value.trim(), source: "env", envVar };
+    }
+    return {};
+}
+/**
+ * Write-then-rename so a Ctrl+C mid-write never leaves a corrupt file.
+ *
+ * The temp file MUST live in the same directory as the target so the rename
+ * is a same-filesystem operation. On many Linux distros `/tmp` is a tmpfs
+ * mount, which would make `renameSync` throw EXDEV across filesystems.
+ */
+function atomicWrite(target, contents) {
+    const dir = dirname(target);
+    ensureDir(dir);
+    const tmp = join(dir, `.fastcode-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`);
+    writeFileSync(tmp, contents, { encoding: "utf8" });
+    renameSync(tmp, target);
+}

package/dist/config/themes.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Built-in color themes. The `banner` triple is fed to gradient-string
+ * (start → mid → end) so each theme produces a recognizable big-text logo.
+ */
+export declare const THEMES: {
+    fastcode: {
+        id: string;
+        label: string;
+        banner: string[];
+        user: string;
+        assistant: string;
+        system: string;
+        border: string;
+        accent: string;
+        muted: string;
+        error: string;
+        success: string;
+    };
+    neon: {
+        id: string;
+        label: string;
+        banner: string[];
+        user: string;
+        assistant: string;
+        system: string;
+        border: string;
+        accent: string;
+        muted: string;
+        error: string;
+        success: string;
+    };
+    sunset: {
+        id: string;
+        label: string;
+        banner: string[];
+        user: string;
+        assistant: string;
+        system: string;
+        border: string;
+        accent: string;
+        muted: string;
+        error: string;
+        success: string;
+    };
+    matrix: {
+        id: string;
+        label: string;
+        banner: string[];
+        user: string;
+        assistant: string;
+        system: string;
+        border: string;
+        accent: string;
+        muted: string;
+        error: string;
+        success: string;
+    };
+    mono: {
+        id: string;
+        label: string;
+        banner: string[];
+        user: string;
+        assistant: string;
+        system: string;
+        border: string;
+        accent: string;
+        muted: string;
+        error: string;
+        success: string;
+    };
+};
+export declare const DEFAULT_THEME = "fastcode";
+export declare function getTheme(id: any): any;

package/dist/config/themes.js

@@ -0,0 +1,77 @@
+/**
+ * Built-in color themes. The `banner` triple is fed to gradient-string
+ * (start → mid → end) so each theme produces a recognizable big-text logo.
+ */
+export const THEMES = {
+    fastcode: {
+        id: "fastcode",
+        label: "FastCode (default)",
+        banner: ["#ff7a00", "#ff2d95", "#7c4dff"],
+        user: "cyan",
+        assistant: "white",
+        system: "gray",
+        border: "magenta",
+        accent: "magenta",
+        muted: "gray",
+        error: "red",
+        success: "green",
+    },
+    neon: {
+        id: "neon",
+        label: "Neon",
+        banner: ["#00ffd0", "#00b3ff", "#7c4dff"],
+        user: "cyanBright",
+        assistant: "whiteBright",
+        system: "gray",
+        border: "cyan",
+        accent: "cyan",
+        muted: "gray",
+        error: "red",
+        success: "greenBright",
+    },
+    sunset: {
+        id: "sunset",
+        label: "Sunset",
+        banner: ["#ff5f6d", "#ffc371", "#ff9966"],
+        user: "yellow",
+        assistant: "whiteBright",
+        system: "gray",
+        border: "yellow",
+        accent: "yellow",
+        muted: "gray",
+        error: "redBright",
+        success: "green",
+    },
+    matrix: {
+        id: "matrix",
+        label: "Matrix",
+        banner: ["#00ff41", "#008f11", "#003b00"],
+        user: "greenBright",
+        assistant: "green",
+        system: "gray",
+        border: "green",
+        accent: "green",
+        muted: "gray",
+        error: "redBright",
+        success: "greenBright",
+    },
+    mono: {
+        id: "mono",
+        label: "Monochrome",
+        banner: ["#ffffff", "#cccccc", "#888888"],
+        user: "white",
+        assistant: "whiteBright",
+        system: "gray",
+        border: "white",
+        accent: "white",
+        muted: "gray",
+        error: "red",
+        success: "white",
+    },
+};
+export const DEFAULT_THEME = "fastcode";
+export function getTheme(id) {
+    if (id && THEMES[id])
+        return THEMES[id];
+    return THEMES[DEFAULT_THEME];
+}

package/dist/config/trust.d.ts

@@ -0,0 +1,22 @@
+export interface TrustPathEntry {
+    grantedAt: string;
+    lastUsed: string;
+}
+export interface TrustToolEntry extends TrustPathEntry {
+    catalogHash: string;
+}
+export interface TrustStore {
+    version: 1;
+    tools: Record<string, TrustToolEntry>;
+    paths: Record<string, TrustPathEntry>;
+}
+export declare function normalizeProjectPath(dir: string): string;
+export declare function loadTrust(): TrustStore;
+export declare function trustAllEnabled(): boolean;
+export declare function isTrusted(dir: string): boolean;
+export declare function trustProject(dir: string): string;
+export declare function untrustProject(dir: string): boolean;
+export declare function listTrusted(): Array<{
+    path: string;
+    addedAt: string;
+}>;