viewable-one 0.0.0-stage → 0.12.1

package/lib/compose.mjs

@@ -0,0 +1,76 @@
+// WHAT A FRESH CHILD'S PROMPT IS BUILT FROM, besides the prompt.
+//
+// Split out of runner.mjs on 2026-09-02, verbatim. Two things get prepended
+// or appended to a FRESH session's prompt - never to a resume, which carries
+// its own conversation memory - and both are composed at spawn time, with no
+// model call:
+//
+//   the repo primer     (lib/repomap.mjs) - the tree and its exported symbols
+//   the attempts section (here) - what earlier runs of this same prompt tried
+//                          and how they failed
+//
+// fromIdOf lives with the board half, because a session's questions hang off
+// what it returns. Imported rather than re-derived: two derivations that
+// drift put a session's questions on a different idea than its run, and
+// nothing errors when they do.
+import { fromIdOf } from "./boardside.mjs";
+
+/** ROWS VERSION (brief 30 Move 2, 2026-09-11) of the section above. Same
+ * bounds, same shape, same "summaries only, never a previous prompt"
+ * reasoning - only the source changed, from `listRequests`/`readRequest`/
+ * `readSpawnReceipt`/`<id>.log` files to `runnerApi.runs`, which the Move 2
+ * contract already needs for maintenance and hands back every run's
+ * `request` and `result` on one project. There is no separate log tail to
+ * read here: `result` IS the receipt text a failed run settled with
+ * (`runnerCompletion.mjs`'s `patch.result`), which already carries the same
+ * closing detail the file version dug out of a `.log` tail. */
+export async function buildAttemptsSectionFromRows(projectId, fromId, currentId, { runnerApi, env, log = () => {} } = {}) {
+  const MAX_SECTION = 6000;
+  const MAX_ATTEMPT = 700;
+
+  const listed = await runnerApi.runs({ projectIds: [projectId] }, { env });
+  if (!listed.ok) {
+    log(`[buildAttemptsSectionFromRows] could not list prior runs: ${listed.error}`);
+    return null;
+  }
+  const priorAttempts = [];
+  for (const run of listed.runs ?? []) {
+    if (run.id === currentId) continue;
+    if (run.status !== "error") continue; // successes and still-open runs carry no attempt
+    const reqFromId = fromIdOf(run.request);
+    if (reqFromId !== fromId) continue;
+    const text = typeof run.result === "string" ? run.result : "";
+    const lines = text.split("\n").slice(3); // past the OK/ERROR line, the file-and-timestamp line, and the blank line
+    const summary = lines.join(" ").trim().slice(0, MAX_ATTEMPT);
+    priorAttempts.push({ id: run.id, summary });
+  }
+
+  if (priorAttempts.length === 0) return null;
+
+  let section = "# Previous attempts\n\n";
+  section += "Earlier sessions for this prompt failed. Their summaries:\n\n";
+
+  const attempts = [];
+  let totalChars = section.length;
+  let dropped = 0;
+
+  for (let i = priorAttempts.length - 1; i >= 0; i--) {
+    const attempt = priorAttempts[i];
+    const attemptNum = priorAttempts.length - i;
+    const attemptText = `**Attempt ${attemptNum}** (${attempt.id}):\n${attempt.summary}\n\n`;
+    if (totalChars + attemptText.length > MAX_SECTION) {
+      dropped = i + 1;
+      break;
+    }
+    attempts.unshift(attemptText);
+    totalChars += attemptText.length;
+  }
+
+  if (dropped > 0) {
+    section += `(${dropped} earlier attempt${dropped === 1 ? "" : "s"} omitted for space)\n\n`;
+  }
+  section += attempts.join("");
+
+  log(`[buildAttemptsSectionFromRows] Found ${priorAttempts.length} prior failure(s) for ${fromId}, included ${attempts.length}, dropped ${dropped}`);
+  return section;
+}

package/lib/computerApps.mjs

@@ -0,0 +1,110 @@
+// #1132: invoked only after a claimed Look request. No model turn, file
+// mutation or app tool call. Config contents never leave this process.
+import { parse as parseJsonc } from 'jsonc-parser';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { prepareCodexApps } from './codexApps.mjs';
+import { execProbe, resolveAgentBinary } from './detect.mjs';
+
+export async function lookForComputerApps({ cwd, env = process.env, platform = process.platform,
+  home = homedir(), read = readFile, probe = execProbe, codex = prepareCodexApps,
+  resolve = resolveAgentBinary } = {}) {
+  const apps = [];
+  const failed = new Set();
+  const add = (name, source, state) => {
+    if (typeof name !== 'string' || !name.trim() || name.length > 120 || /[\x00-\x1f\x7f]/.test(name)) return;
+    if (!apps.some((a) => a.name === name && a.source === source)) apps.push({ name, source, state });
+  };
+  const config = async (path, source, key = 'mcpServers') => {
+    try {
+      const raw = await read(path, 'utf8');
+      if (raw.length > 2_000_000) throw new Error('too large');
+      const errors = [];
+      const data = parseJsonc(raw, errors, { allowTrailingComma: true });
+      if (errors.length) throw new Error("invalid");
+      const servers = data?.[key] ?? {};
+      if (!servers || typeof servers !== 'object' || Array.isArray(servers)) throw new Error('invalid');
+      return { data, names: Object.keys(servers) };
+    } catch (error) {
+      if (error?.code !== 'ENOENT') failed.add(source);
+      return { data: {}, names: [] };
+    }
+  };
+  const claude = await config(join(home, '.claude.json'), 'Claude Code');
+  const project = await config(join(cwd, '.mcp.json'), 'Claude Code');
+  const names = [...new Set([...claude.names, ...project.names,
+    ...Object.keys(claude.data?.projects?.[cwd]?.mcpServers ?? {})])];
+  const claudeBin = await resolve(env.PM_CLAUDE_BIN || 'claude', { env, platform });
+  if (names.length || claudeBin.found) {
+    const bin = claudeBin;
+    const checked = await probe(bin.path, ['mcp', 'list'], { cwd, env, platform, timeoutMs: 15_000 });
+    if (!checked.ok) failed.add('Claude Code');
+    const lines = checked.stdout.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '').split(/\r?\n/);
+    for (const line of lines) {
+      const match = /^([^:]{1,120}):.+(?:Connected|Failed to connect|Needs authentication)\s*$/.exec(line);
+      if (match && !names.includes(match[1])) names.push(match[1]);
+    }
+    for (const name of names) {
+      const line = lines.find((line) => line.startsWith(`${name}:`));
+      add(name, 'Claude Code', checked.ok && /(?:✓|✔) Connected\s*$/.test(line ?? '') ? 'available' : 'unanswered');
+    }
+  }
+  try {
+    const bin = await resolve(env.PM_CODEX_BIN || 'codex', { env, platform });
+    if (bin.found) {
+      const plan = await codex({ bin: bin.path, cwd, env, timeoutMs: 15_000 }, { on: true, isDraft: false });
+      for (const source of plan.sources) add(source.name, 'Codex', source.enabled && source.tools?.length > 0 ? 'available' : 'unanswered');
+    }
+  } catch { failed.add('Codex'); }
+
+  const support = platform === 'darwin' ? join(home, 'Library', 'Application Support')
+    : platform === 'win32' ? env.APPDATA || join(home, 'AppData', 'Roaming')
+    : env.XDG_CONFIG_HOME || join(home, '.config');
+  for (const [path, source, key] of [
+    [join(support, 'Claude', 'claude_desktop_config.json'), 'Claude Desktop', 'mcpServers'],
+    [join(support, 'Code', 'User', 'mcp.json'), 'VS Code', 'servers'],
+    [join(cwd, '.vscode', 'mcp.json'), 'VS Code', 'servers'],
+    [join(home, '.cursor', 'mcp.json'), 'Cursor', 'mcpServers'],
+    [join(cwd, '.cursor', 'mcp.json'), 'Cursor', 'mcpServers'],
+  ]) {
+    const { names } = await config(path, source, key);
+    for (const name of names) add(name, source, 'unsupported');
+  }
+  if (apps.length > 200) throw new Error('Too many computer apps.');
+  return { apps, failed: [...failed] };
+}
+
+// Keep the names-only answer until acknowledged, independently of operation
+// redelivery: claimed Looks no longer appear in the server's heartbeat ops.
+// Scope by API, folder and project; expire superseded/unreachable receipts.
+const pendingResults = new WeakMap();
+
+export async function flushComputerApps(root, project, api, options) {
+  const pending = pendingResults.get(api);
+  let ok = true;
+  for (const [id, entry] of pending ?? []) {
+    if (entry.root !== root || entry.args.projectId !== project.id) continue;
+    if (entry.expires <= Date.now()) { pending.delete(id); continue; }
+    try {
+      const saved = await api.computerAppsResult(entry.args, options);
+      if (saved.ok) pending.delete(id);
+      else ok = false;
+    } catch { ok = false; }
+  }
+  return ok;
+}
+
+export async function serviceComputerApps(root, project, op, api, options, look = lookForComputerApps) {
+  if (op.project_id !== project.id) return false;
+  const args = { projectId: project.id, requestId: op.id };
+  const taken = await api.computerAppsTake(args, options);
+  if (!taken.ok || !taken.taken) return taken.ok;
+  let result;
+  try { result = await look({ cwd: root, env: options.env }); }
+  catch { result = { apps: [], failed: ['Claude Code', 'Codex', 'Claude Desktop', 'VS Code', 'Cursor'] }; }
+  let pending = pendingResults.get(api);
+  if (!pending) pendingResults.set(api, pending = new Map());
+  pending.set(op.id, { root, args: { ...args, result }, expires: Date.now() + 10 * 60_000 });
+  return flushComputerApps(root, project, api, options);
+}

package/lib/conversationRules.mjs

@@ -0,0 +1,45 @@
+// WHAT A SESSION IS TOLD ABOUT THE CONVERSATION ON ITS IDEA (brief 52,
+// 2026-10-04), the tail of preambleFor in agents.mjs. The session is a voice
+// in that conversation: a person's notes reach it as messages, by name; what it
+// says back lands there as its own reply; and a picture of a visible change is
+// worth more than a sentence about it. The closing reply is the runner's
+// (boardside.mjs's reportOutcomeOnBoard files the closing words and the figures
+// once), so the session must not file a second one. Its first sentence is the
+// bold line of the result card (#2023), so it is asked for in those terms.
+export function conversationRules(spec, ask) {
+  return (
+    "A person can write to you while you work. Their note arrives as " +
+    "`[message from <name>] <text>`. Answer them by calling " +
+    `${spec.boardTool("propose")} with an addComment op and no id: it lands in the ` +
+    "conversation on your own idea as your reply. Do that only for an answer " +
+    "the person is waiting on. When you finish, your closing message is filed " +
+    "for you, with the figures, and do not file a second reply of your own. " +
+    "Start it with one sentence of what changed, then at most three short " +
+    "lines as a `- ` list that someone who does not write code can read: no " +
+    "file names, no code.\n\n" +
+    "When you change something a person can see, attach a screenshot of it to " +
+    "an addComment (it takes `images`, up to 6 data URLs of PNG, JPEG, GIF or " +
+    `WebP). When you are choosing between looks, ask with ${ask} and pass ` +
+    "`images` so the person can see each one, and name them in the options.\n\n" +
+    "When you change a page of an app, write `.glytch-page.json` in the root " +
+    "of the folder you work in, naming that page's address and what a person " +
+    "calls it, like `{\"path\": \"/settings\", \"name\": \"settings page\"}`. " +
+    "The runner opens that page for its Before and After pictures; the file " +
+    "is never committed.\n\n"
+  );
+}
+
+// USE MY COMPUTER'S APPS IS OFF (#481). A run without the switch has no way
+// to the person's own apps, so rather than hunt for one it says so in its
+// closing message, in these words: the app finds the sentence and offers
+// Open Manage agent under it.
+export const APPS_OFF_SENTENCE = "Turn on **Use my computer's apps** in Manage agent and I will try again.";
+export function computerAppsOffRule() {
+  return (
+    "You cannot reach the person's own apps from this run (their email, " +
+    "calendar, documents and the like). If the task needs one of them, do " +
+    "not look for a way round it: stop, and end your closing message with " +
+    "these two sentences, naming the app: \"I can't reach your <app> from " +
+    `here. ${APPS_OFF_SENTENCE}"\n\n`
+  );
+}