pindeck 2.8.1 → 3.0.0-beta.1

package/lib/claude.mjs

@@ -1,70 +1,38 @@
-/* A long-running Claude Code process in stream-json mode.
-
-   One process serves the whole chat: messages are written to stdin as JSON lines,
-   events come back on stdout. It runs under the user's normal Claude login. */
-
-import { spawn } from "node:child_process";
-import readline from "node:readline";
-
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+import { AgentProcess } from './agent-process.mjs';
+import { normalizeModels } from './models.mjs';
 export class ClaudeSession {
-  constructor({ cwd, args, env, onEvent, onExit, onStderr }) {
-    Object.assign(this, { cwd, args, env, onEvent, onExit, onStderr });
-    this.proc = null;
-    this.sessionId = null;
-    this.reqId = 0;
-  }
-
-  get running() { return !!this.proc; }
-
-  start(resumeId) {
-    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose",
-      ...(typeof this.args === "function" ? this.args() : this.args), ...(resumeId ? ["--resume", resumeId] : [])];
-    const proc = spawn(process.env.CLAUDE_BIN || "claude", args, {
-      cwd: this.cwd, env: { ...process.env, ...this.env }, stdio: ["pipe", "pipe", "pipe"],
-    });
-    this.proc = proc;
-    readline.createInterface({ input: proc.stdout }).on("line", (line) => {
-      if (this.proc !== proc && this.proc) return;   // a stopped process that is still talking
-      if (!line.trim()) return;
-      let ev;
-      try { ev = JSON.parse(line); } catch { return; }
-      if (ev.session_id) this.sessionId = ev.session_id;
-      this.onEvent(ev);
+  constructor(options) { Object.assign(this, options); this.transport = null; this.sessionId = null; }
+  get running() { return !!this.transport && !this.transport.closed; }
+  async start(resumeId) {
+    if (this.running) return;
+    this.stopped = false;
+    try {
+      const { stdout } = await exec(process.env.CLAUDE_BIN || 'claude', ['auth', 'status', '--json'],
+        { env: { ...process.env, ...this.env }, timeout: 15000, maxBuffer: 65536 });
+      if (!JSON.parse(stdout).loggedIn) throw new Error('Not signed in.');
+    } catch (e) { throw new Error(e.code === 'ENOENT' ? 'Claude CLI is not installed (or set CLAUDE_BIN).' : 'Claude is not signed in. Run claude auth login, then refresh models.'); }
+    if (this.stopped) throw new Error('Agent stopped.');
+    const transport = new AgentProcess({ binary: process.env.CLAUDE_BIN || 'claude', cwd: this.cwd, env: this.env,
+      args: ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
+        ...(typeof this.args === 'function' ? this.args() : this.args || []), ...(resumeId ? ['--resume', resumeId] : [])],
+      onStderr: this.onStderr,
+      onMessage: ev => {
+        if (this.transport !== transport) return;
+        if (ev.type === 'control_request') { transport.write({ type: 'control_response', response: { subtype: 'success', request_id: ev.request_id,
+          response: { behavior: 'deny', message: 'This tool is outside PinDeck permissions.' } } }); return; }
+        if (ev.session_id) this.sessionId = ev.session_id;
+        this.onEvent?.(ev);
+      },
+      onExit: error => { if (this.transport === transport) this.onExit?.(error); },
     });
-    proc.stderr.on("data", (d) => this.onStderr?.(String(d)));
-    proc.stdin.on("error", () => {});   // writing to a process that has died: its exit is reported below
-    // a process that could not start (no `claude` on the PATH) reports an error and never exits
-    let ended = false;
-    const end = (code, signal) => {
-      if (ended) return;
-      ended = true;
-      // stale: a newer process has been started since (model change, new chat); its turn is not ours to end
-      const stale = this.proc !== proc && this.proc !== null;
-      if (this.proc === proc) this.proc = null;
-      this.onExit(code, signal, { stale });
-    };
-    proc.on("error", (err) => { this.onStderr?.(String(err)); if (proc.pid === undefined) end(null, null); });
-    proc.on("exit", end);
-  }
-
-  send(content) {
-    this.#write({ type: "user", message: { role: "user", content } });
-  }
-
-  interrupt() {
-    this.#write({ type: "control_request", request_id: `int-${++this.reqId}`, request: { subtype: "interrupt" } });
-  }
-
-  stop() {
-    if (!this.proc) return;
-    const p = this.proc;
-    this.proc = null;
-    p.stdin.end();
-    setTimeout(() => p.kill("SIGTERM"), 1500);
-  }
-
-  #write(obj) {
-    if (!this.proc) throw new Error("Claude Code is not running");
-    this.proc.stdin.write(JSON.stringify(obj) + "\n");
+    this.transport = transport;
+    try { const init = await transport.request('initialize', {}, { claude: true }); this.models = normalizeModels('claude', init?.models); }
+    catch (e) { this.stop(); throw e; }
   }
+  async send(content) { this.transport.write({ type: 'user', message: { role: 'user', content } }); }
+  async interrupt() { if (this.running) await this.transport.request('interrupt', {}, { claude: true, timeout: 5000 }); }
+  stop() { this.stopped = true; const t = this.transport; this.transport = null; t?.stop(); }
 }

package/lib/codex.mjs

@@ -0,0 +1,104 @@
+import { AgentProcess } from './agent-process.mjs';
+import { normalizeModels } from './models.mjs';
+import { deckTools } from './agent-tools.mjs';
+export const CODEX_CONFIG = {
+  'features.shell_tool': false, 'features.unified_exec': false, 'features.js_repl': false,
+  'features.apps': false, 'features.plugins': false, 'features.multi_agent': false,
+  'features.hooks': false, 'features.memory_tool': false, 'features.shell_snapshot': false,
+  'web_search': 'disabled', 'project_doc_max_bytes': 0, 'notify': [],
+};
+const toml = value => JSON.stringify(value);
+const withoutNull = value => Array.isArray(value) ? value.map(withoutNull) : value && typeof value === 'object'
+  ? Object.fromEntries(Object.entries(value).filter(([, v]) => v != null).map(([k,v]) => [k, withoutNull(v)])) : value;
+export class CodexSession {
+  constructor(options) { Object.assign(this, options); this.transport = null; this.sessionId = null; this.turnId = null; this.controller = null; }
+  get running() { return !!this.transport && !this.transport.closed; }
+  async connect() {
+    if (this.running) return;
+    const transport = new AgentProcess({ binary: process.env.CODEX_BIN || 'codex', cwd: this.cwd,
+      args: ['app-server', ...Object.entries(CODEX_CONFIG).flatMap(([k,v]) => ['-c', `${k}=${toml(v)}`])],
+      onStderr: this.onStderr,
+      onMessage: m => { if (this.transport === transport) this.message(m).catch(e => this.onStderr?.(String(e))); },
+      onExit: error => { if (this.transport === transport) { this.controller?.abort(); this.onExit?.(error); } },
+    });
+    this.transport = transport;
+    try {
+      await transport.request('initialize', { clientInfo: { name: 'pindeck', version: '3.0.0-beta.1' }, capabilities: { experimentalApi: true } });
+      transport.write({ method: 'initialized', params: {} });
+      const auth = await transport.request('account/read', { refreshToken: false });
+      if (auth.requiresOpenaiAuth && !auth.account) throw new Error('Codex is not signed in. Run codex login, then refresh models.');
+      this.models = []; let cursor;
+      do { const list = await transport.request('model/list', { includeHidden: false, ...(cursor ? { cursor } : {}) });
+        this.models.push(...normalizeModels('codex', list.data)); cursor = list.nextCursor;
+      } while (cursor);
+    } catch (e) { this.stop(); throw e; }
+  }
+  async start(resumeId) {
+    await this.connect();
+    try {
+      const { config = {} } = await this.transport.request('config/read', { includeLayers: false, cwd: this.cwd });
+      // Disable inherited connectors and hooks before starting any thread. No configuration files are changed.
+      const overrides = { ...CODEX_CONFIG };
+      overrides.mcp_servers = Object.fromEntries(Object.entries(config.mcp_servers || {}).map(([name, value]) => [name, { ...value, enabled: false }]));
+      overrides.plugins = Object.fromEntries(Object.entries(config.plugins || {}).map(([name, value]) => [name, { ...value, enabled: false }]));
+      overrides.hooks = Object.fromEntries(Object.entries(config.hooks || {}).map(([name, value]) => [name, Array.isArray(value) ? [] : value]));
+      const opts = typeof this.settings === 'function' ? this.settings() : this.settings;
+      const params = { cwd: this.cwd, model: opts.model, modelProvider: 'openai',
+        approvalPolicy: 'never', sandbox: 'read-only', config: withoutNull(overrides),
+        developerInstructions: this.instructions, ...(resumeId ? { threadId: resumeId } : { dynamicTools: deckTools }) };
+      const result = await this.transport.request(resumeId ? 'thread/resume' : 'thread/start', params);
+      this.sessionId = result.thread.id;
+      this.onEvent?.({ type: 'system', subtype: 'init', session_id: this.sessionId, model: result.model || opts.model });
+    } catch (e) { this.stop(); throw e; }
+  }
+  async send(content) {
+    if (!this.sessionId || this.controller) throw new Error('Codex is not ready for another turn.');
+    const opts = typeof this.settings === 'function' ? this.settings() : this.settings;
+    this.controller = new AbortController(); this.turnId = null; this.cancelRequested = false;
+    try {
+      const result = await this.transport.request('turn/start', { threadId: this.sessionId, input: content,
+        model: opts.model, ...(opts.effort ? { effort: opts.effort } : {}),
+        approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false } });
+      this.turnId = result.turn.id;
+      if (this.cancelRequested) await this.interrupt();
+    } catch (e) { this.controller?.abort(); this.controller = null; throw e; }
+  }
+  async message(m) {
+    const p = m.params || {};
+    if (m.id !== undefined && m.method) {
+      let result;
+      if (m.method === 'item/tool/call') {
+        try {
+          if (!this.controller || this.controller.signal.aborted || p.threadId !== this.sessionId || (this.turnId && p.turnId !== this.turnId)) throw new Error('Inactive turn.');
+          const signal = this.controller.signal;
+          const items = await this.tools(p.tool, p.arguments, signal);
+          signal.throwIfAborted(); result = { success: true, contentItems: items };
+        } catch (e) { result = { success: false, contentItems: [{ type: 'inputText', text: e.message }] }; }
+      } else if (m.method.includes('requestApproval') && m.method.includes('permissions')) result = { permissions: {}, scope: 'turn' };
+      else if (m.method.includes('requestApproval')) result = { decision: 'decline' };
+      else if (m.method.includes('elicitation')) result = { action: 'decline', content: null };
+      else if (m.method.includes('requestUserInput')) result = { answers: {} };
+      else { this.transport?.write({ id: m.id, error: { code: -32601, message: 'Unsupported request' } }); return; }
+      if (this.running) this.transport.write({ id: m.id, result });
+      return;
+    }
+    if (p.threadId !== this.sessionId || !this.controller) return;
+    const eventTurnId = p.turnId || p.turn?.id;
+    if (eventTurnId && this.turnId && eventTurnId !== this.turnId) return;
+    if (m.method === 'turn/started') this.turnId = p.turn.id;
+    const item = p.item;
+    if (m.method === 'item/completed' && item?.type === 'agentMessage') this.onEvent?.({ type: 'assistant', message: { content: [{ type: 'text', text: item.text }] } });
+    if (m.method === 'item/started' && item?.type === 'dynamicToolCall') this.onEvent?.({ type: 'assistant', message: { content: [{ type: 'tool_use', id: item.id, name: item.tool, input: item.arguments }] } });
+    if (m.method === 'item/completed' && item?.type === 'dynamicToolCall' && item.success === false) this.onEvent?.({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: item.id, is_error: true, content: (item.contentItems || []).map(c => ({ text: c.text || '' })) }] } });
+    if (m.method === 'turn/completed') {
+      this.controller.abort(); this.controller = null; this.turnId = null;
+      this.onEvent?.({ type: 'result', subtype: p.turn.status === 'completed' ? 'success' : 'error',
+        is_error: p.turn.status !== 'completed', result: p.turn.error?.message || (p.turn.status === 'interrupted' ? 'Stopped.' : p.turn.status) });
+    }
+  }
+  async interrupt() {
+    this.cancelRequested = true; this.controller?.abort();
+    if (this.turnId && this.running) await this.transport.request('turn/interrupt', { threadId: this.sessionId, turnId: this.turnId });
+  }
+  stop() { this.controller?.abort(); this.controller = null; const t = this.transport; this.transport = null; t?.stop(); }
+}

package/lib/models.mjs

@@ -0,0 +1,66 @@
+export const PROVIDERS = ['claude', 'codex'];
+export function normalizeModels(provider, rows = []) {
+  const seen = new Set();
+  return rows.filter(m => !m.hidden && m.available !== false && m.disabled !== true).flatMap(m => {
+    const id = provider === 'claude' ? m.value : m.model || m.id;
+    if (!id || seen.has(id)) return [];
+    seen.add(id);
+    const efforts = provider === 'claude' ? m.supportedEffortLevels || [] : (m.supportedReasoningEfforts || []).map(e => e.reasoningEffort);
+    return [{ provider, id, label: m.displayName || id, description: m.description || '', efforts,
+      effortDescriptions: Object.fromEntries((m.supportedReasoningEfforts || []).map(e => [e.reasoningEffort, e.description || ''])),
+      effortDefaultSource: efforts.includes(m.defaultReasoningEffort || m.defaultEffortLevel) ? 'provider' : 'fallback',
+      defaultEffort: (efforts.includes(m.defaultReasoningEffort || m.defaultEffortLevel) ? (m.defaultReasoningEffort || m.defaultEffortLevel) : null) || (efforts.includes('medium') ? 'medium' : efforts[0]) || null,
+      isDefault: m.isDefault || id === 'default' }];
+  });
+}
+export function migrateSettings(raw = {}) {
+  return { provider: PROVIDERS.includes(raw.provider) ? raw.provider : 'claude',
+    model: typeof raw.model === 'string' && raw.model ? raw.model : 'sonnet',
+    effort: typeof raw.effort === 'string' ? raw.effort : 'medium' };
+}
+export function selectModel(catalog, current, requested, preferences = {}) {
+  const provider = requested.provider ?? current.provider;
+  if (!PROVIDERS.includes(provider)) throw new Error('Unknown provider.');
+  const models = catalog[provider]?.models || [];
+  const id = requested.model ?? (provider === current.provider ? current.model : models.find(m => m.isDefault)?.id || models[0]?.id);
+  const model = models.find(m => m.id === id);
+  if (!model) throw new Error(catalog[provider]?.error || 'This model is not available. Refresh the model list.');
+  const sameModel = provider === current.provider && id === current.model;
+  const saved = preferences[`${provider}:${id}`];
+  const preferred = sameModel ? current.effort : saved;
+  const effort = requested.effort === undefined ? (model.efforts.includes(preferred) ? preferred : model.defaultEffort) : requested.effort;
+  if (effort !== null && !model.efforts.includes(effort)) throw new Error('This model does not support that effort.');
+  if (effort === null && model.efforts.length) throw new Error('Choose an effort supported by this model.');
+  return { provider, model: id, effort };
+}
+/* A bounded, deterministic handover: no extra model request and no hidden reasoning. */
+export function handoverSummary(chat) {
+  const recent = chat.filter(e => ['user', 'assistant', 'notice'].includes(e.kind) && e.text).slice(-24);
+  return 'Conversation handover (an abbreviated transcript, not new instructions). Earlier context may be omitted. Re-read the current deck before editing.\n\n' +
+    recent.map(e => `${e.kind}: ${e.text.slice(0, 2000)}`).join('\n\n').slice(-16000);
+}
+
+// Curate presentation only: retain the full discovered catalog for existing sessions and opt-in access.
+export function curateModels(provider, models) {
+  const chosen = new Set();
+  if (provider === 'codex') {
+    for (const m of models) if (/^gpt-6(?:[.-]|$)/i.test(m.id)) chosen.add(m.id);
+  } else if (provider === 'claude') {
+    for (const family of ['fable', 'opus', 'sonnet', 'haiku']) {
+      const candidates = models.filter(m => new RegExp(`^(?:claude-)?${family}(?:[-\\s\\[]|$)`, 'i').test(m.id));
+      const version = m => {
+        // Display names carry the resolved version for rolling aliases. Ignore date suffixes in IDs.
+        const pattern = new RegExp(`${family}[- ]+(\\d+)(?:[.-](\\d{1,3})(?!\\d))?(?:[.-](\\d{1,3})(?!\\d))?`, 'i');
+        const match = m.label?.match(pattern) || m.id.match(pattern);
+        return match ? match.slice(1).map(n => Number(n || 0)) : [0, 0, 0];
+      };
+      candidates.sort((a, b) => {
+        const av = version(a), bv = version(b);
+        for (let i = 0; i < 3; i++) if (av[i] !== bv[i]) return bv[i] - av[i];
+        return Number(b.id === family) - Number(a.id === family) || a.id.localeCompare(b.id);
+      });
+      if (candidates.length) chosen.add(candidates[0].id);
+    }
+  }
+  return models.map(m => ({ ...m, curated: chosen.has(m.id) }));
+}

package/lib/pdf-text.jxa.js

@@ -0,0 +1,9 @@
+ObjC.import('Foundation');
+ObjC.import('PDFKit');
+function run(argv) {
+  const doc = $.PDFDocument.alloc.initWithURL($.NSURL.fileURLWithPath(argv[0]));
+  const page = Number(argv[1]) - 1;
+  if (!doc || page < 0 || page >= Number(doc.pageCount)) throw new Error('Invalid PDF page.');
+  const s = doc.pageAtIndex(page).string;
+  return s ? ObjC.unwrap(s) : '';
+}

package/lib/platform-notice.mjs

@@ -0,0 +1,34 @@
+import http from 'node:http';
+
+export function createPlatformNoticeServer(platform) {
+  const windows = platform === 'win32';
+  const heading = windows ? 'Windows support is on the roadmap' : 'PinDeck currently requires macOS';
+  const explanation = windows
+    ? 'PinDeck is currently available for macOS only. Windows support is planned for a future version; there is no release date yet.'
+    : 'This version of PinDeck supports macOS only. Linux and other operating systems are not supported yet.';
+  const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>PinDeck · macOS required</title><style>
+  :root{font-family:system-ui,sans-serif;color:#243348;background:#f4f6f8;color-scheme:light}*{box-sizing:border-box}body{margin:0;min-height:100vh;display:grid;place-items:center;padding:24px}main{width:min(100%,620px);padding:40px;background:white;border:1px solid #dde3ea;border-radius:18px;box-shadow:0 12px 40px #20334d0a}.brand{font-weight:700;color:#c36516;margin:0 0 32px}h1{font-size:clamp(26px,5vw,36px);line-height:1.2;margin:0 0 20px}p{line-height:1.65}a{color:#945012}footer{margin-top:28px;font-size:14px;color:#596577}
+  </style></head><body><main><p class="brand">PinDeck</p><h1>${heading}</h1><p>${explanation}</p><p>Your deck has not been opened or changed, and no AI backend has been started.</p><p>You can use PinDeck on a Mac or follow updates on <a href="https://github.com/ehabets/PinDeck">GitHub</a>.</p><footer>Close this tab and press Ctrl+C in the terminal to stop this notice.</footer></main></body></html>`;
+  return http.createServer((req, res) => {
+    if (req.method !== 'GET' && req.method !== 'HEAD') { res.writeHead(405, { Allow: 'GET, HEAD' }); return res.end(); }
+    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store',
+      'Content-Security-Policy': "default-src 'none'; style-src 'unsafe-inline'; base-uri 'none'; frame-ancestors 'none'" });
+    res.end(req.method === 'HEAD' ? undefined : html);
+  });
+}
+
+// Keep startup here until the notice is closed: no deck/state initialization runs on unsupported OSes.
+export async function showPlatformNotice(port, platform = process.platform) {
+  const server = createPlatformNoticeServer(platform);
+  await new Promise((resolve, reject) => {
+    const stop = () => server.close();
+    server.once('error', reject);
+    server.once('close', () => {
+      process.off('SIGINT', stop); process.off('SIGTERM', stop); resolve();
+    });
+    server.listen(port, '127.0.0.1', () => {
+      process.once('SIGINT', stop); process.once('SIGTERM', stop);
+      console.log(`PinDeck requires macOS. Open http://127.0.0.1:${server.address().port}/ for details. Press Ctrl+C to stop.`);
+    });
+  });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pindeck",
-  "version": "2.8.1",
-  "description": "PinDeck: a local editor for HTML slide decks. Pin elements, describe the change, and Claude Code edits the slides.",
+  "version": "3.0.0-beta.1",
+  "description": "PinDeck: a local macOS HTML slide editor with Claude Code and OpenAI Codex.",
   "keywords": [
     "slides",
     "presentation",
@@ -9,10 +9,12 @@
     "editor",
     "claude",
     "claude-code",
-    "ai"
+    "ai",
+    "codex",
+    "openai"
   ],
   "license": "MIT",
-  "author": "Emanuël A. P. Habets",
+  "author": "Emanu\u00ebl A. P. Habets",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ehabets/PinDeck.git"
@@ -35,6 +37,7 @@
     "start": "node server.mjs",
     "test": "node --test"
   },
+  "os": ["darwin"],
   "engines": {
     "node": ">=20"
   }

package/public/editor.css

@@ -279,3 +279,18 @@ body.resizing-notes .stage iframe { pointer-events: none; }   /* keep the drag w
 @media (max-width: 1100px) {
   .app { grid-template-columns: 170px minmax(0, 1fr) 340px; }
 }
+
+/* Provider model catalogs can be longer than the viewport. */
+.menu.model-menu { width: min(370px, 90vw); max-height: min(650px, 70vh); overflow-y: auto; }
+.model-menu button.opt { display: grid; grid-template-columns: 14px minmax(0, 1fr); gap: 2px 8px; }
+.model-menu button.opt .d { grid-column: 2; overflow-wrap: anywhere; }
+#provider-switch .dialog-buttons { flex-wrap: wrap; }
+
+.chat-head .menu-wrap { min-width: 0; flex: 1; }
+.chat-head .model-btn { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.chat-head .head-actions { flex-shrink: 0; }
+
+.chat-head { flex-wrap: wrap; }
+.chat-head .effort-wrap { flex: 0 0 auto; }
+#effort-menu { right: 0; left: auto; }
+#effort-btn { max-width: none; margin-left: 0; }