autopreso 0.1.1

package/src/cli-options.js

@@ -0,0 +1,29 @@
+export function parseCliArgs(args, env = process.env) {
+  const options = {
+    host: "127.0.0.1",
+    port: parsePort(env.PORT),
+    openBrowser: true,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--no-open") {
+      options.openBrowser = false;
+    } else if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown argument "${arg}".`);
+    }
+  }
+
+  return options;
+}
+
+function parsePort(value) {
+  const raw = value || "3210";
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`Invalid PORT "${raw}".`);
+  }
+  return port;
+}

package/src/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import os from "node:os";
+import path from "node:path";
+import open from "open";
+
+import { resolveAgentProviderFromSettings } from "./agent-provider.js";
+import { parseCliArgs } from "./cli-options.js";
+import { startServer } from "./server.js";
+import { createSettingsStore } from "./settings-store.js";
+
+const SETTINGS_PATH = path.join(os.homedir(), ".config", "autopreso", "settings.json");
+
+async function main() {
+  let options;
+  try {
+    options = parseCliArgs(process.argv.slice(2));
+  } catch (error) {
+    console.error(error.message);
+    console.error("Run `autopreso --help` for usage.");
+    process.exitCode = 1;
+    return;
+  }
+
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const settingsStore = createSettingsStore({ filePath: SETTINGS_PATH });
+  const settings = await settingsStore.load();
+
+  let agentProvider;
+  try {
+    agentProvider = resolveAgentProviderFromSettings({ settings, env: process.env });
+  } catch (error) {
+    console.error(`Whiteboard agent is not configured: ${error.message}`);
+    console.error("Open the app and configure the agent in the status panel, or set OPENAI_API_KEY / OLLAMA_MODEL in your shell.");
+    console.error(`Settings file: ${SETTINGS_PATH}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (settings.transcription.provider === "openai" && !(settings.apiKeys?.openai || process.env.OPENAI_API_KEY)) {
+    console.error("OpenAI transcription is selected but no API key is configured.");
+    console.error("Open the app and add the key in the STT engine row, or set OPENAI_API_KEY in your shell.");
+    process.exitCode = 1;
+    return;
+  }
+
+  const { url } = await startServer({
+    ...options,
+    settingsStore,
+    onStatus: (message) => console.log(message),
+  });
+
+  console.log(`autopreso listening at ${url}`);
+  console.log(`whiteboard agent: ${agentProvider.provider} ${agentProvider.requestedModel ?? agentProvider.model}`);
+  console.log(`settings file: ${SETTINGS_PATH}`);
+
+  if (options.openBrowser) {
+    await open(url);
+  }
+}
+
+function printHelp() {
+  console.log(`autopreso
+
+Usage:
+  autopreso [options]
+
+Options:
+  --no-open                Do not open the browser automatically
+  -h, --help               Show this help
+
+The server binds to 127.0.0.1 only.
+
+Environment:
+  PORT                     Port to listen on. Default: 3210
+  OPENAI_API_KEY           Seeds the OpenAI key on first run if no settings file exists
+  OPENAI_MODEL             Seeds the OpenAI agent model on first run
+  OPENAI_REASONING_EFFORT  Seeds reasoning effort on first run (none, low, medium, high, xhigh)
+  CODEX_HOME               Codex CLI home directory. Default: ~/.codex
+  CODEX_MODEL              Seeds the Codex model on first run
+  CODEX_BASE_URL           Seeds the Codex backend URL on first run
+  OLLAMA_MODEL             Seeds the Ollama model on first run
+  OLLAMA_BASE_URL          Seeds the Ollama base URL on first run
+
+Models and providers are configured in the UI after launch. Settings persist at:
+  ${SETTINGS_PATH}
+`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/src/codex-auth.js

@@ -0,0 +1,135 @@
+import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex";
+const CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const CODEX_OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+const CODEX_ACCESS_TOKEN_REFRESH_SKEW_MS = 120_000;
+
+export function readCodexCliAuthSync(env = process.env) {
+  const authPath = codexAuthPath(env);
+  if (!existsSync(authPath)) return undefined;
+
+  try {
+    const payload = JSON.parse(readFileSync(authPath, "utf8"));
+    return parseCodexAuthPayload(payload);
+  } catch {
+    return undefined;
+  }
+}
+
+export async function resolveCodexCliCredentials(env = process.env, options = {}) {
+  const authPath = codexAuthPath(env);
+  const payload = JSON.parse(readFileSync(authPath, "utf8"));
+  const auth = parseCodexAuthPayload(payload);
+  if (!auth) {
+    throw new Error(`Codex CLI auth is missing usable tokens at ${authPath}. Run \`codex\` and sign in with ChatGPT.`);
+  }
+
+  let tokens = { ...auth.tokens };
+  if (codexAccessTokenIsExpiring(tokens.access_token, options.now ?? Date.now())) {
+    tokens = await refreshCodexTokens(tokens, options.fetchFn ?? fetch);
+    payload.tokens = { ...payload.tokens, ...tokens };
+    writeCodexAuthPayload(authPath, payload);
+  }
+
+  return {
+    provider: "codex",
+    baseURL: cleanEnvValue(env.CODEX_BASE_URL) ?? DEFAULT_CODEX_BASE_URL,
+    apiKey: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    accountId: auth.accountId,
+  };
+}
+
+export function createCodexFetch(env = process.env) {
+  return async (input, init = {}) => {
+    const credentials = await resolveCodexCliCredentials(env);
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${credentials.apiKey}`);
+    if (credentials.accountId) {
+      headers.set("ChatGPT-Account-Id", credentials.accountId);
+    }
+    return fetch(input, { ...init, headers });
+  };
+}
+
+function codexAuthPath(env) {
+  return join(cleanEnvValue(env.CODEX_HOME) ?? join(homedir(), ".codex"), "auth.json");
+}
+
+function parseCodexAuthPayload(payload) {
+  if (!payload || typeof payload !== "object") return undefined;
+  const tokens = payload.tokens;
+  if (!tokens || typeof tokens !== "object") return undefined;
+  const accessToken = cleanEnvValue(tokens.access_token);
+  const refreshToken = cleanEnvValue(tokens.refresh_token);
+  if (!accessToken || !refreshToken) return undefined;
+  return {
+    tokens: { ...tokens, access_token: accessToken, refresh_token: refreshToken },
+    accessToken,
+    refreshToken,
+    accountId: cleanEnvValue(payload.account_id) ?? extractAccountId(accessToken),
+  };
+}
+
+function codexAccessTokenIsExpiring(accessToken, nowMs) {
+  const exp = decodeJwtPayload(accessToken)?.exp;
+  if (typeof exp !== "number") return false;
+  return exp * 1000 <= nowMs + CODEX_ACCESS_TOKEN_REFRESH_SKEW_MS;
+}
+
+async function refreshCodexTokens(tokens, fetchFn) {
+  const response = await fetchFn(CODEX_OAUTH_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded", Accept: "application/json" },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: tokens.refresh_token,
+      client_id: CODEX_OAUTH_CLIENT_ID,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Codex token refresh failed with status ${response.status}. Run \`codex\` and sign in with ChatGPT.`);
+  }
+
+  const payload = await response.json();
+  const accessToken = cleanEnvValue(payload.access_token);
+  if (!accessToken) {
+    throw new Error("Codex token refresh response was missing access_token.");
+  }
+
+  return {
+    ...tokens,
+    access_token: accessToken,
+    refresh_token: cleanEnvValue(payload.refresh_token) ?? tokens.refresh_token,
+  };
+}
+
+function writeCodexAuthPayload(authPath, payload) {
+  const tmpPath = `${authPath}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`);
+  chmodSync(tmpPath, 0o600);
+  renameSync(tmpPath, authPath);
+}
+
+function extractAccountId(accessToken) {
+  const claims = decodeJwtPayload(accessToken);
+  return cleanEnvValue(claims?.chatgpt_account_id) ?? cleanEnvValue(claims?.["https://api.openai.com/auth"]?.chatgpt_account_id);
+}
+
+function decodeJwtPayload(token) {
+  if (typeof token !== "string" || token.split(".").length !== 3) return undefined;
+  try {
+    return JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+function cleanEnvValue(value) {
+  const trimmedValue = value?.trim();
+  return trimmedValue || undefined;
+}

package/src/moonshine-transcription.js

@@ -0,0 +1,146 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const require = createRequire(import.meta.url);
+const SAMPLE_RATE = 24000;
+const SIDECAR_PACKAGE_BY_PLATFORM = new Map([
+  ["darwin:arm64", "@autopreso/moonshine-darwin-arm64"],
+  ["darwin:x64", "@autopreso/moonshine-darwin-x64"],
+]);
+
+export function moonshinePlatformPackageName(platform = process.platform, arch = process.arch) {
+  const packageName = SIDECAR_PACKAGE_BY_PLATFORM.get(`${platform}:${arch}`);
+  if (!packageName) {
+    throw new Error("Moonshine local transcription is currently available for macOS arm64 and x64.");
+  }
+  return packageName;
+}
+
+export function resolveMoonshineSidecarPath({
+  env = process.env,
+  platform = process.platform,
+  arch = process.arch,
+  requireResolve = require.resolve,
+} = {}) {
+  if (env.AUTOPRESO_MOONSHINE_BIN) return env.AUTOPRESO_MOONSHINE_BIN;
+
+  const packageName = moonshinePlatformPackageName(platform, arch);
+  const packageJsonPath = requireResolve(`${packageName}/package.json`);
+  return path.join(path.dirname(packageJsonPath), "bin", "autopreso-moonshine");
+}
+
+export function createMoonshineTranscription({
+  sendTranscript,
+  queueTranscript,
+  options,
+  spawnProcess = spawn,
+  resolveSidecarPath = () => resolveMoonshineSidecarPath(),
+}) {
+  let child = null;
+  let stdoutBuffer = "";
+  let readyPromise = null;
+  let resolveReady = null;
+  let rejectReady = null;
+
+  function ensureChild() {
+    if (child) return child;
+
+    const binary = resolveSidecarPath();
+    readyPromise = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+    child = spawnProcess(binary, ["--model", options.moonshineModel, "--language", "en"], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    child.stdout.on("data", (chunk) => {
+      stdoutBuffer += chunk.toString("utf8");
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        handleSidecarLine(line, { sendTranscript, queueTranscript, onReady: resolveReady });
+      }
+    });
+
+    child.stderr.on("data", (chunk) => {
+      const message = chunk.toString("utf8").trim();
+      if (message) sendTranscript({ type: "error", message });
+    });
+
+    child.on("error", (error) => {
+      sendTranscript({ type: "error", message: error.message });
+      rejectReady?.(error);
+    });
+
+    child.on("close", (code) => {
+      rejectReady?.(new Error(`Moonshine sidecar exited before it was ready${code === null ? "" : ` (code ${code})`}.`));
+      child = null;
+      readyPromise = null;
+      resolveReady = null;
+      rejectReady = null;
+    });
+
+    return child;
+  }
+
+  return {
+    ready: async () => {
+      ensureChild();
+      await readyPromise;
+    },
+    sendAudio: (audio) => {
+      if (!audio) return;
+      let process;
+      try {
+        process = ensureChild();
+      } catch (error) {
+        sendTranscript({ type: "error", message: error.message });
+        return;
+      }
+      process.stdin.write(`${JSON.stringify({ type: "audio", encoding: "pcm16le", sampleRate: SAMPLE_RATE, audio })}\n`);
+    },
+    stop: () => {
+      if (!child) return;
+      child.stdin.write(`${JSON.stringify({ type: "stop" })}\n`);
+    },
+    close: () => {
+      if (!child) return;
+      child.stdin.end();
+      child.kill();
+      child = null;
+    },
+  };
+}
+
+function handleSidecarLine(line, { sendTranscript, queueTranscript, onReady }) {
+  if (!line.trim()) return;
+
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    sendTranscript({ type: "error", message: `Invalid Moonshine sidecar message: ${line}` });
+    return;
+  }
+
+  if (message.type === "ready") {
+    onReady?.();
+    return;
+  }
+
+  if (message.type === "transcript:partial") {
+    sendTranscript({ type: "transcript:partial", text: message.text ?? "" });
+  }
+
+  if (message.type === "transcript:committed") {
+    const text = message.text ?? "";
+    sendTranscript({ type: "transcript:committed", text });
+    queueTranscript(text);
+  }
+
+  if (message.type === "error") {
+    sendTranscript({ type: "error", message: message.message ?? "Moonshine transcription error" });
+  }
+}

package/src/openai-transcription.js

@@ -0,0 +1,186 @@
+import { WebSocket } from "ws";
+
+const REALTIME_URL = "wss://api.openai.com/v1/realtime?intent=transcription";
+
+export function createOpenAITranscription({
+  sendTranscript,
+  queueTranscript,
+  options,
+  env = process.env,
+  createWebSocket = (url, protocols, init) => new WebSocket(url, protocols, init),
+}) {
+  let socket = null;
+  let readyPromise = null;
+  let resolveReady = null;
+  let rejectReady = null;
+  let configured = false;
+  let pendingAudio = [];
+  let partialText = "";
+  let bufferedSinceCommit = false;
+
+  function ensureSocket() {
+    if (socket) return socket;
+
+    const apiKey = env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("OPENAI_API_KEY is required for the OpenAI transcription provider.");
+    }
+
+    readyPromise = new Promise((resolve, reject) => {
+      resolveReady = resolve;
+      rejectReady = reject;
+    });
+
+    socket = createWebSocket(REALTIME_URL, undefined, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+
+    socket.on("open", () => {
+      configured = true;
+      socket.send(JSON.stringify({
+        type: "session.update",
+        session: {
+          type: "transcription",
+          audio: {
+            input: {
+              format: { type: "audio/pcm", rate: 24000 },
+              transcription: { model: options.openaiTranscriptionModel },
+            },
+          },
+        },
+      }));
+      for (const audio of pendingAudio) {
+        socket.send(JSON.stringify({ type: "input_audio_buffer.append", audio }));
+      }
+      pendingAudio = [];
+    });
+
+    socket.on("message", (raw) => {
+      handleSocketMessage(raw.toString("utf8"), {
+        sendTranscript,
+        queueTranscript,
+        onReady: () => resolveReady?.(),
+        getPartial: () => partialText,
+        setPartial: (value) => { partialText = value; },
+        onBufferDrained: () => { bufferedSinceCommit = false; },
+      });
+    });
+
+    socket.on("error", (error) => {
+      sendTranscript({ type: "error", message: error.message });
+      rejectReady?.(error);
+    });
+
+    socket.on("close", () => {
+      rejectReady?.(new Error("OpenAI realtime socket closed before it was ready."));
+      socket = null;
+      readyPromise = null;
+      resolveReady = null;
+      rejectReady = null;
+      configured = false;
+      pendingAudio = [];
+      partialText = "";
+      bufferedSinceCommit = false;
+    });
+
+    return socket;
+  }
+
+  return {
+    ready: async () => {
+      try {
+        ensureSocket();
+      } catch (error) {
+        sendTranscript({ type: "error", message: error.message });
+        throw error;
+      }
+      await readyPromise;
+    },
+    sendAudio: (audio) => {
+      if (!audio) return;
+      let connection;
+      try {
+        connection = ensureSocket();
+      } catch (error) {
+        sendTranscript({ type: "error", message: error.message });
+        return;
+      }
+      if (!configured) {
+        pendingAudio.push(audio);
+        bufferedSinceCommit = true;
+        return;
+      }
+      connection.send(JSON.stringify({ type: "input_audio_buffer.append", audio }));
+      bufferedSinceCommit = true;
+    },
+    stop: () => {
+      if (!socket || !configured) return;
+      // If server-side VAD already auto-committed (or no audio was sent), skip the manual
+      // commit - OpenAI rejects commits on empty buffers with "buffer too small".
+      if (!bufferedSinceCommit) return;
+      socket.send(JSON.stringify({ type: "input_audio_buffer.commit" }));
+      bufferedSinceCommit = false;
+    },
+    close: () => {
+      if (!socket) return;
+      socket.close();
+      socket = null;
+    },
+  };
+}
+
+function handleSocketMessage(line, { sendTranscript, queueTranscript, onReady, getPartial, setPartial, onBufferDrained }) {
+  if (!line.trim()) return;
+
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    sendTranscript({ type: "error", message: `Invalid OpenAI realtime message: ${line}` });
+    return;
+  }
+
+  if (
+    message.type === "transcription_session.created" ||
+    message.type === "transcription_session.updated" ||
+    message.type === "session.created" ||
+    message.type === "session.updated"
+  ) {
+    onReady?.();
+    return;
+  }
+
+  if (message.type === "conversation.item.input_audio_transcription.delta") {
+    const next = getPartial() + (message.delta ?? "");
+    setPartial(next);
+    sendTranscript({ type: "transcript:partial", text: next });
+    return;
+  }
+
+  if (message.type === "conversation.item.input_audio_transcription.completed") {
+    const text = message.transcript ?? "";
+    setPartial("");
+    onBufferDrained?.();
+    sendTranscript({ type: "transcript:committed", text });
+    queueTranscript(text);
+    return;
+  }
+
+  // Server VAD commits the buffer well before transcription completes, and
+  // discards silent audio outright. Track the actual buffer state from this
+  // signal so a later stop() doesn't try to commit an empty buffer.
+  if (message.type === "input_audio_buffer.committed") {
+    onBufferDrained?.();
+    return;
+  }
+
+  if (message.type === "error") {
+    // input_audio_buffer_commit_empty is a benign race: server VAD already
+    // drained (or discarded silent audio) before our manual commit landed.
+    // Don't surface it to the UI.
+    if (message.error?.code === "input_audio_buffer_commit_empty") return;
+    sendTranscript({ type: "error", message: message.error?.message ?? "OpenAI realtime error" });
+  }
+}