flint-agent 1.14.0

package/src/providers/models.js

@@ -0,0 +1,154 @@
+// Fetch models from provider API — unified format
+
+import { getProvider } from "./registry.js";
+import { getKey } from "./keys.js";
+import { createLogger } from "../logging/logger.js";
+
+const log = createLogger("models");
+
+export async function fetchModels(providerId) {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    log.warn("fetchModels: unknown provider", { providerId });
+    return [];
+  }
+
+  if (!provider.modelsEndpoint) {
+    // Static models fallback
+    if (provider.staticModels) {
+      return provider.staticModels.map((m) => ({
+        id: m.id,
+        name: m.name || m.id,
+        context_length: m.context_length || null,
+        pricing: null,
+      }));
+    }
+    return [];
+  }
+
+  const apiKey = await getKey(providerId);
+
+  try {
+    const headers = { ...provider.headers };
+    if (provider.authType === "bearer" && apiKey) {
+      headers["Authorization"] = `Bearer ${apiKey}`;
+    } else if (provider.authType === "x-api-key" && apiKey) {
+      headers["x-api-key"] = apiKey;
+    }
+
+    const url = provider.ollamaCompat
+      ? `${provider.baseUrl}${provider.modelsEndpoint}`
+      : `${provider.baseUrl}${provider.modelsEndpoint}`;
+
+    const res = await fetch(url, {
+      headers,
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      log.warn("fetchModels: http error", { providerId, status: res.status, body: body.slice(0, 200) });
+      return [];
+    }
+    const data = await res.json();
+
+    // Anthropic format: { data: [{ id, display_name, type: "model", created_at }] }
+    if (provider.format === "anthropic") {
+      const models = data.data || [];
+      return models.map((m) => ({
+        id: m.id,
+        name: m.display_name || m.id,
+        context_length: null,
+        pricing: null,
+      }));
+    }
+
+    // Ollama format
+    if (provider.ollamaCompat) {
+      const models = data.models || [];
+      return models.map((m) => ({
+        id: m.name || m.model,
+        name: m.name || m.model,
+        context_length: null,
+        pricing: null,
+      }));
+    }
+
+    // OpenAI-compatible format (OpenRouter, OpenAI, Groq, Together)
+    const rawModels = data.data || [];
+
+    // Filter out non-chat models (audio, image, embedding, moderation, tts, realtime, sora, etc.)
+    const NON_CHAT = /^(tts|whisper|dall-e|text-embedding|text-moderation|davinci|babbage|canary|omni-moderation|sora|gpt-image|gpt-audio|gpt-realtime|chatgpt-image)/;
+    const NON_CHAT_SUFFIX = /(-(audio|realtime|transcribe|tts|diarize)(-|$))/;
+
+    const filtered = rawModels
+      .filter((m) => {
+        if (NON_CHAT.test(m.id)) return false;
+        if (NON_CHAT_SUFFIX.test(m.id)) return false;
+        // OpenRouter marks modality — keep only models that output text.
+        // New OpenRouter schema uses architecture.output_modalities: ["text", ...]
+        // Legacy schema uses architecture.modality: "text->text" or "text+image->text"
+        const arch = m.architecture;
+        if (arch) {
+          if (Array.isArray(arch.output_modalities) && arch.output_modalities.length > 0) {
+            if (!arch.output_modalities.includes("text")) return false;
+          } else if (typeof arch.modality === "string" && arch.modality) {
+            // Check the output side (after "->") — if absent, use whole string
+            const outputSide = arch.modality.includes("->")
+              ? arch.modality.split("->")[1]
+              : arch.modality;
+            if (!outputSide.includes("text")) return false;
+          }
+        }
+        return true;
+      })
+      .map((m) => ({
+        id: m.id,
+        name: m.name || m.id,
+        context_length: m.context_length || null,
+        // What the model accepts, when the provider publishes it: true/false
+        // for images, null when it does not say.
+        sees_images: seesImagesFrom(m.architecture),
+        pricing: m.pricing ? {
+          prompt: parseFloat(m.pricing.prompt || 0),
+          completion: parseFloat(m.pricing.completion || 0),
+          // Third price line, two orders of magnitude below `prompt`. Without
+          // it any local estimate of a cached call is off by ~100x.
+          cacheRead: m.pricing.input_cache_read != null
+            ? parseFloat(m.pricing.input_cache_read)
+            : null,
+        } : null,
+      }));
+
+    log.info("fetchModels", { providerId, raw: rawModels.length, filtered: filtered.length });
+    return filtered;
+  } catch (err) {
+    log.warn("fetchModels: exception", { providerId, error: err.message });
+    return [];
+  }
+}
+
+// OpenRouter: architecture.input_modalities ["text", "image", ...], or the
+// legacy architecture.modality "text+image->text". Absent means unknown, not no.
+export function seesImagesFrom(arch) {
+  if (!arch) return null;
+  if (Array.isArray(arch.input_modalities) && arch.input_modalities.length > 0) {
+    return arch.input_modalities.includes("image");
+  }
+  if (typeof arch.modality === "string" && arch.modality.includes("->")) {
+    return arch.modality.split("->")[0].includes("image");
+  }
+  return null;
+}
+
+export async function fetchModelInfo(providerId, modelId) {
+  const models = await fetchModels(providerId);
+  const model = models.find((m) => m.id === modelId);
+  if (!model) return null;
+  return {
+    prompt: model.pricing?.prompt || 0,
+    completion: model.pricing?.completion || 0,
+    cacheRead: model.pricing?.cacheRead ?? null,
+    contextLength: model.context_length || null,
+    seesImages: model.sees_images ?? null,
+  };
+}

package/src/providers/registry.js

@@ -0,0 +1,56 @@
+// Provider registry — loads from config/providers.json, falls back to bundled defaults
+
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CONFIG_PATH = join(__dirname, "../../config/providers.json");
+// homedir(), not process.env.HOME: HOME is unset on Windows.
+const USER_CONFIG_PATH = join(homedir(), ".flint", "providers.json");
+
+function loadProviders() {
+  // User config (~/.flint/providers.json) takes priority, then project config
+  for (const path of [USER_CONFIG_PATH, CONFIG_PATH]) {
+    try {
+      if (existsSync(path)) {
+        const raw = JSON.parse(readFileSync(path, "utf-8"));
+        // Add id field from key if missing
+        const providers = {};
+        for (const [id, def] of Object.entries(raw)) {
+          if (id.startsWith("_")) continue; // skip comments
+          providers[id] = { id, headers: {}, ...def };
+        }
+        return providers;
+      }
+    } catch {}
+  }
+  // Should not happen — config/providers.json is bundled
+  return {};
+}
+
+export const PROVIDERS = loadProviders();
+
+export function getProvider(id) {
+  return PROVIDERS[id] || null;
+}
+
+export function listProviders() {
+  return Object.values(PROVIDERS);
+}
+
+export function getProviderIds() {
+  return Object.keys(PROVIDERS);
+}
+
+/**
+ * Reload providers from config (e.g. after user edits ~/.flint/providers.json).
+ */
+export function reloadProviders() {
+  const fresh = loadProviders();
+  // Clear and repopulate
+  for (const key of Object.keys(PROVIDERS)) delete PROVIDERS[key];
+  Object.assign(PROVIDERS, fresh);
+  return PROVIDERS;
+}

package/src/providers/state.js

@@ -0,0 +1,56 @@
+// Provider state persistence — active provider + last model per provider
+// File: ~/.flint/provider.json
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const FLINT_DIR = path.join(homedir(), ".flint");
+const STATE_FILE = path.join(FLINT_DIR, "provider.json");
+
+const DEFAULT_STATE = {
+  activeProvider: "openrouter",
+  lastModel: {},
+};
+
+function load() {
+  if (!existsSync(STATE_FILE)) return { ...DEFAULT_STATE, lastModel: {} };
+  try {
+    const data = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+    return {
+      activeProvider: data.activeProvider || DEFAULT_STATE.activeProvider,
+      lastModel: data.lastModel || {},
+    };
+  } catch {
+    return { ...DEFAULT_STATE, lastModel: {} };
+  }
+}
+
+function save(state) {
+  mkdirSync(FLINT_DIR, { recursive: true });
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+}
+
+export function getActiveProvider() {
+  return load().activeProvider;
+}
+
+export function setActiveProvider(providerId) {
+  const state = load();
+  state.activeProvider = providerId;
+  save(state);
+}
+
+export function getLastModel(providerId) {
+  return load().lastModel[providerId] || null;
+}
+
+export function setLastModel(providerId, modelId) {
+  const state = load();
+  state.lastModel[providerId] = modelId;
+  save(state);
+}
+
+export function getProviderState() {
+  return load();
+}

package/src/registry.js

@@ -0,0 +1,96 @@
+/**
+ * Agent registry -- tracks running Flint instances.
+ * File at ~/.flint/agents.json with 0o600 permissions.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { apiUrl } from "./api/address.js";
+
+const FLINT_DIR = path.join(homedir(), ".flint");
+const REGISTRY_FILE = path.join(FLINT_DIR, "agents.json");
+
+function ensureDir() {
+  mkdirSync(FLINT_DIR, { recursive: true, mode: 0o700 });
+}
+
+function readRegistry() {
+  try {
+    if (!existsSync(REGISTRY_FILE)) return [];
+    const data = JSON.parse(readFileSync(REGISTRY_FILE, "utf-8"));
+    return Array.isArray(data) ? data : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeRegistry(entries) {
+  const tmp = REGISTRY_FILE + ".tmp." + process.pid;
+  try {
+    ensureDir();
+    writeFileSync(tmp, JSON.stringify(entries, null, 2), { mode: 0o600 });
+    renameSync(tmp, REGISTRY_FILE);
+  } catch {
+    // Rename can fail (e.g. EPERM on Windows when the target is open);
+    // clean up the tmp sibling so we don't leak on every write. Previously
+    // used `require("node:fs")` mid-function which always threw in ESM,
+    // leaving 345 agents.json.tmp.<pid> orphans in ~/.flint over months.
+    try { unlinkSync(tmp); } catch {}
+  }
+}
+
+/**
+ * Register this agent instance.
+ */
+export function registerAgent({ port, sessionId, model, profile, pid, provider, visible }) {
+  const entries = readRegistry().filter((e) => e.pid !== pid);
+  entries.push({
+    port,
+    sessionId,
+    model,
+    profile: profile || "desktop",
+    pid,
+    provider: provider || null,
+    visible: visible !== false,
+    startedAt: new Date().toISOString(),
+  });
+  writeRegistry(entries);
+}
+
+/**
+ * Unregister this agent instance.
+ */
+export function unregisterAgent(pid) {
+  const entries = readRegistry().filter((e) => e.pid !== pid);
+  writeRegistry(entries);
+}
+
+/**
+ * List all registered agents, optionally checking if they're alive.
+ */
+export async function listAgents({ checkAlive = false } = {}) {
+  let entries = readRegistry();
+
+  if (checkAlive) {
+    const alive = [];
+    for (const entry of entries) {
+      try {
+        const res = await fetch(apiUrl(entry.port, "/status"), {
+          signal: AbortSignal.timeout(1000),
+        });
+        if (res.ok) {
+          const status = await res.json();
+          alive.push({ ...entry, ...status, alive: true });
+        }
+      } catch {
+        // dead -- skip
+      }
+    }
+    // Clean up dead entries
+    writeRegistry(alive.map(({ alive, ...rest }) => rest));
+    return alive;
+  }
+
+  return entries;
+}

package/src/restart.js

@@ -0,0 +1,29 @@
+// Restart Flint and keep the session.
+//
+// Exit code 42 tells the launcher to start Flint again, and it used to start
+// it with --new: every restart (/restart, POST /restart, restart_agent) left
+// the conversation behind. Owner, 2026-10-02: an investigation in progress
+// was cut off by a restart and had to be found again with /sessions.
+//
+// Before exiting, the session id goes to the launcher over the IPC channel it
+// opens for us (launcher.js), and the launcher starts the new process with
+// --session <id>. Run without a launcher (no IPC) it is a plain exit 42.
+
+export const RESTART_CODE = 42;
+
+/**
+ * Exit for a restart after `delayMs`, telling the launcher which session to
+ * continue. The exit waits for the message to be sent.
+ */
+export function restartKeepingSession(sessionId, delayMs = 100, proc = process) {
+  setTimeout(() => {
+    const exit = () => proc.exit(RESTART_CODE);
+    if (sessionId && typeof proc.send === "function" && proc.connected !== false) {
+      try {
+        proc.send({ type: "flint:restart", sessionId }, () => exit());
+        return;
+      } catch {}
+    }
+    exit();
+  }, delayMs);
+}

package/src/sandbox/backend.js

@@ -0,0 +1,130 @@
+// Sandbox backend — isolates shell command execution.
+//
+// Backends:
+//   local  — current behavior, runs directly on host (default, dev mode)
+//   docker — spawns per-session container, all commands inside
+//
+// Config: AGENT_SANDBOX env var (local|docker)
+// Internal task reference removed.
+
+import { spawn } from "node:child_process";
+import { config } from "../config.js";
+import os from "node:os";
+import path from "node:path";
+
+const SANDBOX_MODE = process.env.AGENT_SANDBOX || "local";
+const DOCKER_IMAGE = process.env.AGENT_SANDBOX_IMAGE || "node:20-slim";
+
+let _activeContainer = null;
+
+/**
+ * Get current sandbox mode.
+ */
+export function getSandboxMode() {
+  return SANDBOX_MODE;
+}
+
+/**
+ * Initialize sandbox for a session.
+ * For docker: creates a container. For local: no-op.
+ * @param {string} sessionId
+ * @param {string} workdir — host directory to mount
+ */
+export async function initSandbox(sessionId, workdir) {
+  if (SANDBOX_MODE !== "docker") return;
+
+  const name = `flint-sandbox-${sessionId.replace(/[^a-zA-Z0-9-]/g, "").slice(0, 30)}`;
+
+  // Create container with workdir mounted
+  const args = [
+    "create", "--name", name,
+    "-w", "/workdir",
+    "-v", `${workdir}:/workdir`,
+    "--network", "none", // no outbound by default
+    DOCKER_IMAGE,
+    "sleep", "infinity",
+  ];
+
+  await runHost("docker", args, 30000);
+  await runHost("docker", ["start", name], 10000);
+  _activeContainer = name;
+}
+
+/**
+ * Execute a command in the sandbox.
+ * For docker: docker exec. For local: direct spawn.
+ * @param {string} command — shell command
+ * @param {string} cwd — working directory
+ * @param {object} opts — { shell, env, timeout, signal }
+ * @returns {Promise<{child, shell, shellArgs}>} — compatible with existing run_command flow
+ */
+export function wrapCommand(command, cwd, opts = {}) {
+  if (SANDBOX_MODE === "docker" && _activeContainer) {
+    // Route through docker exec
+    const dockerArgs = [
+      "exec", "-w", "/workdir",
+      _activeContainer,
+      "bash", "-c", command,
+    ];
+    return {
+      shell: "docker",
+      shellArgs: dockerArgs,
+      cwd: undefined, // docker handles cwd internally
+      env: opts.env || process.env,
+    };
+  }
+
+  // Local mode — passthrough
+  return {
+    shell: opts.shell || config.shell,
+    shellArgs: ["-c", command],
+    cwd,
+    env: opts.env,
+  };
+}
+
+/**
+ * Cleanup sandbox at session end.
+ * For docker: removes the container.
+ */
+export async function cleanupSandbox() {
+  if (SANDBOX_MODE !== "docker" || !_activeContainer) return;
+  try {
+    await runHost("docker", ["rm", "-f", _activeContainer], 15000);
+  } catch {}
+  _activeContainer = null;
+}
+
+/**
+ * Check if Docker is available on host.
+ */
+export async function isDockerAvailable() {
+  try {
+    await runHost("docker", ["--version"], 5000);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Helper: run a command on HOST (not in sandbox)
+function runHost(cmd, args, timeout = 30000) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const child = spawn(cmd, args, { stdio: ["pipe", "pipe", "pipe"] });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`${cmd} timeout after ${timeout}ms`));
+    }, timeout);
+    child.stdout.on("data", d => stdout += d);
+    child.stderr.on("data", d => stderr += d);
+    child.on("close", code => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(`${cmd} exit ${code}: ${stderr.slice(0, 200)}`));
+    });
+  });
+}
+
+export const __internal = { SANDBOX_MODE, DOCKER_IMAGE };

package/src/security/api-auth.js

@@ -0,0 +1,132 @@
+// API authentication — token-based auth for the HTTP server
+
+import crypto from "node:crypto";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { isPairedToken } from "./pairing.js";
+
+const FLINT_DIR = join(homedir(), ".flint");
+const TOKEN_FILE = join(FLINT_DIR, "api-token.json");
+// Token TTL: 30 days. After expiry, a fresh one is generated on next startup.
+const TOKEN_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+
+/**
+ * Generate a random 48-character hex token.
+ * @returns {string} API token
+ */
+export function generateApiToken() {
+  return crypto.randomBytes(24).toString("hex");
+}
+
+/**
+ * Load a persisted API token if it exists and hasn't expired.
+ * Otherwise generate a new one and persist it.
+ * Returns the token string.
+ */
+export function loadOrCreateApiToken() {
+  try {
+    if (existsSync(TOKEN_FILE)) {
+      const data = JSON.parse(readFileSync(TOKEN_FILE, "utf-8"));
+      if (data.token && typeof data.token === "string" && typeof data.expiresAt === "number") {
+        if (Date.now() < data.expiresAt) {
+          return data.token;
+        }
+      }
+    }
+  } catch {
+    // Fall through to generate a new token
+  }
+
+  const token = generateApiToken();
+  try {
+    mkdirSync(FLINT_DIR, { recursive: true });
+    const payload = {
+      token,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + TOKEN_TTL_MS,
+    };
+    writeFileSync(TOKEN_FILE, JSON.stringify(payload, null, 2), { encoding: "utf-8", mode: 0o600 });
+  } catch {
+    // Persist failed — still return the in-memory token
+  }
+  return token;
+}
+
+/**
+ * The token-file key to the HTTP API, only when the operator asked for it
+ * with FLINT_API_TOKEN_FILE=1 (automation that starts its own Flint).
+ *
+ * Owner, 2026-10-02: by default nothing can just connect. Any program running
+ * as the same user could read ~/.flint/api-token.json and send tasks that run
+ * with the API's automatic approval; a benchmark runner drove a console that
+ * way. Without the variable no file is read or written, and a program gets in
+ * only by pairing (a PIN the operator sees in the console).
+ * @returns {string|null}
+ */
+export function masterTokenIfEnabled() {
+  return process.env.FLINT_API_TOKEN_FILE === "1" ? loadOrCreateApiToken() : null;
+}
+
+/**
+ * Constant-time token comparison.
+ */
+function tokenEquals(a, b) {
+  const bufA = Buffer.from(a, "utf-8");
+  const bufB = Buffer.from(b, "utf-8");
+  if (bufA.length !== bufB.length) return false;
+  return crypto.timingSafeEqual(bufA, bufB);
+}
+
+/**
+ * Create auth middleware function.
+ * @param {string|null} token - The token-file key (masterTokenIfEnabled), or
+ *   null: then only paired programs and a parent's spawn secret get in. No
+ *   token never means "no auth"; that fail-open let anything in.
+ * @returns {Function} (req, res) => boolean — returns true if authorized, false if rejected (response already sent)
+ */
+export function createAuthMiddleware(token) {
+  // Collect additional valid tokens: spawn secret from parent
+  const spawnSecret = process.env.AGENT_PAIRING_SECRET || null;
+
+  return function authMiddleware(req, res) {
+    // Skip auth for OPTIONS (CORS preflight) and GET /status (health check)
+    if (req.method === "OPTIONS") return true;
+
+    const url = new URL(req.url, `http://localhost`);
+    if (url.pathname === "/status" && req.method === "GET") return true;
+
+    // Skip auth for pairing endpoints
+    if (url.pathname.startsWith("/pair/")) return true;
+
+    // Check Authorization header
+    const authHeader = req.headers.authorization;
+    if (!authHeader) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Authorization required. Use: Authorization: Bearer <token>" }));
+      return false;
+    }
+
+    const parts = authHeader.split(" ");
+    if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer") {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Invalid token" }));
+      return false;
+    }
+
+    const candidate = parts[1];
+
+    // Check the token-file key, when enabled (constant-time)
+    if (token && tokenEquals(candidate, token)) return true;
+
+    // Check spawn secret from parent (constant-time)
+    if (spawnSecret && tokenEquals(candidate, spawnSecret)) return true;
+
+    // Check paired tokens
+    if (isPairedToken(candidate)) return true;
+
+    res.writeHead(403, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Invalid token" }));
+    return false;
+  };
+}