agentbox-app 0.1.6

package/main/code-file.mjs

@@ -0,0 +1,116 @@
+// READING AND WRITING ONE FILE INSIDE A CHANGE.
+//
+// The pane already types onto a markdown file in the product's own folders
+// (main/doc-file.mjs). This is the same job for the other kind of artifact, and
+// it is a harder one for two reasons.
+//
+//   1. THE FILE IS NOT IN THE PRODUCT'S FOLDERS. It is source in a checkout the
+//      run worked in, and the change records it as a short path like
+//      `renderer/src/api.ts`, which on its own does not say which checkout.
+//      So a change now carries `roots` and each file carries `abs`
+//      (main/code-change.mjs). This finds the file from those and refuses if it
+//      cannot, rather than guessing at a path and writing over a stranger's.
+//   2. WHAT IS ON THE SCREEN IS NOT THE WHOLE FILE. The splice back into the
+//      real bytes is pure and lives in renderer/src/code-edit.ts; by the time
+//      anything here runs, the caller has the file's WHOLE new text.
+//
+// THE RULE ON WHERE A WRITE MAY LAND: inside one of the change's own roots, or
+// inside the product's folders. Nowhere else. That is the same shape as
+// doc-file.mjs, keyed to the change instead of to a fixed list, because the
+// checkout is the run's and not the app's.
+import fsDefault from 'node:fs';
+import path from 'node:path';
+import { artifactRoots } from './artifact-path.mjs';
+import { isInside } from './doc-file.mjs';
+
+// Half a megabyte of one source file. Past that the change artifact is not what
+// she should be editing in, and a truncation would eat the file on save.
+export const MAX_CODE_BYTES = 800_000;
+
+/** The roots a change's files may sit under: the run's own, plus the product's. */
+export function rootsFor(change, product) {
+  const out = [];
+  for (const r of change?.roots ?? []) if (typeof r === 'string' && r) out.push(r);
+  for (const r of artifactRoots(product)) if (r) out.push(r);
+  return out;
+}
+
+/**
+ * Where one file of a change really is.
+ *
+ * `abs` is taken when the change carries it, because that is what the run
+ * actually wrote and needs no guessing. Otherwise the short path is tried
+ * against each root and the first one that EXISTS wins — existence rather than
+ * order, because a product's docs dir and its checkout can both plausibly hold
+ * `designs/x.html` and only one of them does.
+ *
+ * A change written before 2026-08-24 has neither, and then there is nothing
+ * honest to do but say so.
+ */
+export function findFile({ change, product, filePath, fs = fsDefault }) {
+  if (!filePath) return { ok: false, error: 'No file was named.' };
+  const entry = (change?.files ?? []).find((f) => f?.path === filePath) ?? null;
+  if (!entry) return { ok: false, error: 'That file is not part of this change.' };
+
+  const tries = [];
+  if (typeof entry.abs === 'string' && entry.abs) tries.push(entry.abs);
+  if (path.isAbsolute(filePath)) tries.push(filePath);
+  for (const root of rootsFor(change, product)) tries.push(path.join(root, filePath));
+
+  for (const candidate of tries) {
+    try { if (fs.statSync(candidate).isFile()) return { ok: true, path: candidate }; } catch { /* next */ }
+  }
+  return {
+    ok: false,
+    error: 'That file could not be found on this machine, so it cannot be edited here.',
+  };
+}
+
+/** May the pane write onto this file, for this product? */
+export function canWriteCode({ file, change, product, fs = fsDefault }) {
+  const roots = rootsFor(change, product);
+  if (!roots.length) return { ok: false, error: 'This change does not say which folder it came from, so nothing was saved.' };
+  if (!roots.some((root) => isInside(root, file))) {
+    return { ok: false, error: 'That file is outside the folders this run worked in, so nothing was saved.' };
+  }
+  if (!fs.existsSync(file)) return { ok: false, error: 'That file is no longer there, so nothing was saved.' };
+  return { ok: true };
+}
+
+/** The bytes of one file of a change, with when it last moved. */
+export function readCodeFile({ file, fs = fsDefault }) {
+  let stat;
+  try { stat = fs.statSync(file); } catch { return { ok: false, error: 'That file is no longer there.' }; }
+  if (stat.size > MAX_CODE_BYTES) {
+    return { ok: false, error: 'That file is too big to edit here.' };
+  }
+  try {
+    return { ok: true, path: file, text: fs.readFileSync(file, 'utf8'), mtime: stat.mtimeMs };
+  } catch (err) {
+    return { ok: false, error: String(err?.message ?? err).slice(0, 200) };
+  }
+}
+
+/**
+ * Her edit, onto the source file.
+ */
+export function writeCodeFile({ file, change, product, text, mtime, fs = fsDefault }) {
+  const allowed = canWriteCode({ file, change, product, fs });
+  if (!allowed.ok) return allowed;
+  if (typeof text !== 'string') return { ok: false, error: 'Nothing to save.' };
+  if (mtime) {
+    let now = 0;
+    try { now = fs.statSync(file).mtimeMs; } catch { /* handled above */ }
+    if (now && now - mtime > 1000) {
+      return { ok: false, stale: true, error: 'Something else changed this file while you were typing, so nothing was saved.' };
+    }
+  }
+  try {
+    fs.writeFileSync(file, text, 'utf8');
+    let after = 0;
+    try { after = fs.statSync(file).mtimeMs; } catch { /* the write succeeded */ }
+    return { ok: true, mtime: after, path: file };
+  } catch (err) {
+    return { ok: false, error: String(err?.message ?? err).slice(0, 200) };
+  }
+}

package/main/codex-account.mjs

@@ -0,0 +1,146 @@
+// WHICH CODEX ACCOUNT THIS MAC IS SIGNED INTO.
+//
+// THE CARD USED TO HAVE A REASON FOR SAYING NOTHING, AND THE REASON HAS EXPIRED.
+// renderer/src/components/Settings.tsx carried this, written when the Codex card
+// was built: "`~/.codex/auth.json` carries a mode and an opaque account id, no
+// email and no plan, and a uuid is not a person." That was true of the Codex CLI
+// of the day. It is not true of 0.153.4, measured on her Mac 2026-09-18: the
+// `id_token` beside those fields carries `email`, `name`, and a
+// `chatgpt_plan_type` of "pro". So the half of "connected, and signed in as"
+// that had no honest answer now has one, and Codex's card can say what Claude
+// Code's account rows have always said.
+//
+// THE CLI ITSELF WILL NOT TELL YOU. `codex login status` answers "Logged in
+// using ChatGPT" and names nobody, so there is nothing to shell out to even if
+// we wanted to pay for a process. This is a read of one small file.
+//
+// NOTHING SECRET LEAVES THIS MODULE. `auth.json` holds an access token, a
+// refresh token and an API key, and none of them are returned, logged, or put on
+// any wire. The id_token's signature is not checked and does not need to be:
+// this is not authenticating anybody, it is reading the name off a credential
+// the machine already trusts, to print it back to the person who put it there.
+// A forged one would only mislabel her own screen.
+//
+// IT IS READ WHEN THE PAGE ASKS, NOT KEPT. Settings is opened by hand a few
+// times a day and she can sign in or out between two of those, so a cached
+// answer is a screen that can be quietly wrong. Same judgement main/claude-plan.
+// mjs makes for the Claude plan, and for the same reason.
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/** The claim OpenAI hangs its ChatGPT facts off, verbatim. */
+const AUTH_CLAIM = 'https://api.openai.com/auth';
+
+/**
+ * The plan ids whose proper names are known. Everything else is printed exactly
+ *  as Codex spells it, and that is deliberate: her own token reads "prolite",
+ *  which title-cases into "Prolite", a product name nobody at OpenAI has ever
+ *  used. Inventing a label is how a screen tells a confident lie about what
+ *  somebody is paying for, so an id we do not know is shown as the id. */
+const PLANS = { free: 'Free', plus: 'Plus', pro: 'Pro', business: 'Business', team: 'Team', enterprise: 'Enterprise', edu: 'Edu' };
+
+function planLabel(raw) {
+  const s = String(raw ?? '').trim().toLowerCase();
+  if (!s) return null;
+  return PLANS[s] ?? s;
+}
+
+/**
+ * Whether that label is a name anybody uses, or the raw id. The screen says
+ *  "On the Pro plan" for one and "Codex reports the plan as prolite" for the
+ *  other, because "On the prolite plan" reads like our typo rather than like
+ *  Codex's word. */
+function planIsNamed(raw) {
+  const s = String(raw ?? '').trim().toLowerCase();
+  return !!s && !!PLANS[s];
+}
+
+/**
+ * The middle of a JWT, which is plain base64url JSON. No verification: see the
+ *  header of this file for why there is nothing here to verify. */
+function claims(token) {
+  if (typeof token !== 'string') return null;
+  const part = token.split('.')[1];
+  if (!part) return null;
+  try {
+    const padded = part + '='.repeat((4 - (part.length % 4)) % 4);
+    const json = JSON.parse(Buffer.from(padded, 'base64url').toString('utf8'));
+    return json && typeof json === 'object' ? json : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Where this login lives. `configured` is the workspace's CODEX_HOME when it has
+ *  one, which is the same rule main/supervisor.mjs `_codexHome` follows. */
+export function codexAuthFile(home = null) {
+  return path.join(home || path.join(os.homedir(), '.codex'), 'auth.json');
+}
+
+/**
+ * WHO IS SIGNED INTO CODEX UNDER THIS HOME, or null because nobody is.
+ *
+ * Null is an ordinary answer and the card falls back to saying only that Codex is
+ * connected, exactly as it did before this existed. Every field is independently
+ * nullable: an account signed in with an API key has no email and no plan, and
+ * the card then says the one true thing it can.
+ *
+ * @returns {{ email: string|null, name: string|null, plan: string|null,
+ *   mode: string|null, accountId: string|null }|null}
+ */
+export function codexAccount(home = null, { file = null } = {}) {
+  const at = file ?? codexAuthFile(home);
+  let auth = null;
+  try { auth = JSON.parse(fs.readFileSync(at, 'utf8')); } catch { return null; }
+  if (!auth || typeof auth !== 'object') return null;
+
+  const id = claims(auth?.tokens?.id_token);
+  const chatgpt = id?.[AUTH_CLAIM] ?? null;
+  const email = typeof id?.email === 'string' && id.email.trim() ? id.email.trim() : null;
+  const name = typeof id?.name === 'string' && id.name.trim() ? id.name.trim() : null;
+  const plan = planLabel(chatgpt?.chatgpt_plan_type);
+  // The uuid, which is nobody's name and is only worth drawing when there is no
+  // email to draw instead. Claude Code's rows make the same choice.
+  const accountId = typeof auth?.tokens?.account_id === 'string' && auth.tokens.account_id
+    ? auth.tokens.account_id
+    : (typeof chatgpt?.chatgpt_account_id === 'string' ? chatgpt.chatgpt_account_id : null);
+  const mode = typeof auth?.auth_mode === 'string' && auth.auth_mode ? auth.auth_mode : null;
+
+  if (!email && !name && !plan && !accountId) return null;
+  return { email, name, plan, planNamed: planIsNamed(chatgpt?.chatgpt_plan_type), mode, accountId };
+}
+
+/**
+ * A FOLDER FOR THE NEXT CODEX LOGIN, MADE BEFORE ANYTHING IS ASKED TO USE IT.
+ *
+ * The command the card handed her was simply wrong: codex-cli will not create
+ * the home it is pointed at, so the folder has to exist first. Making it here,
+ * in the app, is better than telling her to run one more line.
+ *
+ * THE NAME IS COUNTED, NEVER GUESSED. `~/.codex-2` and up, skipping anything
+ * that exists, so pressing Add twice cannot hand the second login the first
+ * one's folder and overwrite a working account.
+ *
+ * @returns {{ home: string, profile: string }} `profile` is the word the fleet
+ *   spawns on, which for every home but her primary one IS the path.
+ */
+export function makeCodexHome({ home = os.homedir(), mkdir = fs.mkdirSync, exists = fs.existsSync } = {}) {
+  for (let n = 2; n < 100; n += 1) {
+    const dir = path.join(home, `.codex-${n}`);
+    if (exists(dir)) continue;
+    mkdir(dir, { recursive: true });
+    return { home: dir, profile: dir };
+  }
+  throw new Error('There are already a lot of Codex folders in your home directory.');
+}
+
+/**
+ * The one line that signs a new account in, for the terminal to run. The home
+ *  is spelled out rather than left to the shell, because `~` inside a variable
+ *  assignment is not expanded by every shell the same way. */
+export function codexLoginCommand(home) {
+  return `CODEX_HOME=${home} codex login`;
+}