bloby-bot 0.47.0 → 0.47.1

package/bin/cli.js

@@ -17,13 +17,34 @@ const CONFIG_PATH = path.join(DATA_DIR, 'config.json');
 const BIN_DIR = path.join(DATA_DIR, 'bin');
 const CF_PATH = path.join(BIN_DIR, 'cloudflared');
 
-// ── Ensure dependencies exist (self-heal if postinstall npm install failed) ──
-if (!IS_DEV && !fs.existsSync(path.join(ROOT, 'node_modules', 'viem'))) {
+// ── Ensure dependencies exist (self-heal if postinstall/update npm install failed) ──
+// Check every declared dep, not just one sentinel: a release that adds a new
+// dep would otherwise silently boot into an `ERR_MODULE_NOT_FOUND` crash loop.
+function missingDeps(root) {
+  let deps;
   try {
-    execSync('npm install --omit=dev', { cwd: ROOT, stdio: 'inherit' });
+    deps = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8')).dependencies || {};
   } catch {
-    console.error('\n  ✗  Failed to install dependencies. Run manually:\n      cd ~/.bloby && npm install\n');
-    process.exit(1);
+    return [];
+  }
+  return Object.keys(deps).filter(d => !fs.existsSync(path.join(root, 'node_modules', d, 'package.json')));
+}
+
+if (!IS_DEV) {
+  const missing = missingDeps(ROOT);
+  if (missing.length > 0) {
+    console.error(`\n  Installing missing dependencies: ${missing.slice(0, 5).join(', ')}${missing.length > 5 ? `, +${missing.length - 5} more` : ''}\n`);
+    try {
+      execSync('npm install --omit=dev', { cwd: ROOT, stdio: 'inherit' });
+    } catch {
+      console.error('\n  ✗  Failed to install dependencies. Run manually:\n      cd ~/.bloby && npm install\n');
+      process.exit(1);
+    }
+    const stillMissing = missingDeps(ROOT);
+    if (stillMissing.length > 0) {
+      console.error(`\n  ✗  Dependencies still missing after npm install: ${stillMissing.join(', ')}\n      Try: cd ~/.bloby && rm -rf node_modules package-lock.json && npm install --omit=dev\n`);
+      process.exit(1);
+    }
   }
 }
 
@@ -1498,11 +1519,24 @@ async function update() {
 
   const distDst = path.join(DATA_DIR, 'dist-bloby');
 
-  // Install dependencies (5 min timeout to prevent hanging forever)
+  // Install dependencies (5 min timeout to prevent hanging forever).
+  // A failed install while new source files are already in place leaves the
+  // app permanently broken (e.g. crash loop on a new import). Treat as fatal,
+  // surface the npm output so the cause is debuggable, and don't claim success.
   try {
-    execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'ignore', timeout: 300_000 });
+    execSync('npm install --omit=dev', { cwd: DATA_DIR, stdio: 'inherit', timeout: 300_000 });
   } catch (e) {
-    console.log(`  ${c.yellow}⚠${c.reset}  npm install issue: ${e.message}`);
+    console.log(`\n  ${c.red}✗${c.reset}  npm install failed during update: ${e.message}`);
+    console.log(`    Your install is now partially upgraded. To recover:\n      cd ~/.bloby && npm install --omit=dev\n`);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    process.exit(1);
+  }
+  const stillMissing = missingDeps(DATA_DIR);
+  if (stillMissing.length > 0) {
+    console.log(`\n  ${c.red}✗${c.reset}  npm install reported success but these deps are missing: ${stillMissing.join(', ')}`);
+    console.log(`    Try: cd ~/.bloby && rm -rf node_modules package-lock.json && npm install --omit=dev\n`);
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    process.exit(1);
   }
   stepper.advance();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloby-bot",
-  "version": "0.47.0",
+  "version": "0.47.1",
   "releaseNotes": [
     "1. # voice note (PTT bubble)",
     "2. # audio file + caption",
@@ -49,7 +49,8 @@
     "start": "node --import tsx/esm supervisor/index.ts",
     "postinstall": "node scripts/postinstall.js",
     "dev:workspace": "vite",
-    "dev:docs": "cd ./docs && npx fumapress"
+    "dev:docs": "cd ./docs && npx fumapress",
+    "sync:pi-models": "tsx scripts/sync-pi-models.ts"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.138",

package/scripts/postinstall.js

@@ -73,8 +73,25 @@ try {
     cwd: BLOBY_HOME,
     stdio: 'inherit',
   });
-} catch {
-  console.error('Warning: failed to install dependencies in ~/.bloby/ — run "cd ~/.bloby && npm install" manually');
+} catch (e) {
+  // Don't swallow this — partial deps leave bloby in a crash loop on first
+  // start (e.g. missing @anthropic-ai/claude-agent-sdk after a release that
+  // adds a new dep). The CLI has a self-heal pass but only triggers when the
+  // user runs `bloby` again, so make the failure visible here too.
+  console.error(`\nError: npm install failed in ${BLOBY_HOME}: ${e.message}`);
+  console.error(`Run manually: cd ${BLOBY_HOME} && npm install --omit=dev\n`);
+  process.exit(1);
+}
+
+// Verify every declared dependency actually landed on disk.
+const installedDeps = JSON.parse(fs.readFileSync(path.join(BLOBY_HOME, 'package.json'), 'utf-8')).dependencies || {};
+const missing = Object.keys(installedDeps).filter(
+  d => !fs.existsSync(path.join(BLOBY_HOME, 'node_modules', d, 'package.json'))
+);
+if (missing.length > 0) {
+  console.error(`\nError: npm install reported success but these deps are missing: ${missing.join(', ')}`);
+  console.error(`Try: cd ${BLOBY_HOME} && rm -rf node_modules package-lock.json && npm install --omit=dev\n`);
+  process.exit(1);
 }
 
 // ── Prune wrong-libc claude-agent-sdk native package ──

package/scripts/sync-pi-models.ts

@@ -0,0 +1,146 @@
+/**
+ * Sync the pi model catalog into Bloby.
+ *
+ * Reads upstream pi's `packages/ai/src/models.generated.ts` (vendored as a
+ * sibling checkout at ../pi-main) and emits a filtered, alphabetised TS file
+ * the wizard imports. Run on demand when you want to pull in newer model IDs.
+ *
+ *   npm run sync:pi-models
+ *
+ * The OUTPUT (`supervisor/harnesses/pi/models-catalog.generated.ts`) is the
+ * file that ships with bloby. The pi-main checkout is dev-only and is not
+ * required at runtime.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..');
+const PI_MODELS_PATH = path.join(REPO_ROOT, 'pi-main', 'packages', 'ai', 'src', 'models.generated.ts');
+const OUTPUT_PATH = path.join(REPO_ROOT, 'supervisor', 'harnesses', 'pi', 'models-catalog.generated.ts');
+
+if (!fs.existsSync(PI_MODELS_PATH)) {
+  console.error(`✗  pi catalog not found at ${PI_MODELS_PATH}`);
+  console.error('   Clone or download earendil-works/pi into ../pi-main first.');
+  process.exit(1);
+}
+
+// Bloby sub-provider id → pi MODELS top-level key.
+// Sub-providers without a pi mapping (ollama, lm-studio, custom) stay dynamic.
+const PROVIDER_MAP: Record<string, string> = {
+  google: 'google',
+  deepseek: 'deepseek',
+  groq: 'groq',
+  xai: 'xai',
+  cerebras: 'cerebras',
+  mistral: 'mistral',
+  'openai-api': 'openai',
+  'anthropic-api': 'anthropic',
+  // openrouter intentionally skipped — 270+ entries is wizard-hostile. Stays dynamic.
+};
+
+// Drop noisy variants: date-suffixed previews, custom-tool forks, live-audio,
+// model-snapshot aliases. We keep the canonical id (e.g. "gemini-3.1-pro-preview")
+// and the rolling "*-latest" handles, which is what users actually want to pick.
+const HIDDEN_PATTERNS: RegExp[] = [
+  /-\d{2}-\d{2}$/,             // ...-04-17
+  /-\d{2}-\d{4}$/,             // ...-09-2025
+  /-\d{4}-\d{2}-\d{2}$/,       // ...-2025-08-07
+  /-\d{8}$/,                   // ...-20250805
+  /-customtools$/,
+  /-live-/,
+  /-search-preview/,
+  /-realtime/,
+  /-audio/,
+  /-tts$/,
+  /-transcribe$/,
+  /^text-embedding-/,
+  /^omni-moderation/,
+  /^dall-e/,
+  /^whisper/,
+  /^gpt-3\.5/,                 // legacy
+  /^gpt-4-/,                   // legacy variants of plain gpt-4
+  /^o1-/,                      // dated o1 variants
+  /^gemma-/,                   // separate open-weight family — better served via Ollama
+];
+
+function isHidden(id: string): boolean {
+  return HIDDEN_PATTERNS.some((re) => re.test(id));
+}
+
+async function loadPiModels(): Promise<Record<string, Record<string, { id: string; name?: string }>>> {
+  // pi's file has `import type { Model } from "./types.js"` — strip that line
+  // so the module loads without needing pi's full types graph at sync time.
+  const raw = fs.readFileSync(PI_MODELS_PATH, 'utf-8');
+  const sanitised = raw
+    .replace(/^import type[^;]+;\s*$/m, '')
+    .replace(/ satisfies Model<[^>]+>/g, '');
+
+  // Drop into a temp file next to the original so any relative paths in errors
+  // still make sense, then dynamic-import via file:// URL.
+  const tmpPath = `${PI_MODELS_PATH}.bloby-sync.tmp.ts`;
+  fs.writeFileSync(tmpPath, sanitised);
+  try {
+    const mod = await import(pathToFileURL(tmpPath).href);
+    return (mod as any).MODELS;
+  } finally {
+    fs.rmSync(tmpPath, { force: true });
+  }
+}
+
+function versionScore(id: string): number {
+  // Cheap "newer first" ordering: parse the first major.minor pair we find.
+  const m = id.match(/(\d+)(?:\.(\d+))?/);
+  if (!m) return 0;
+  const major = parseInt(m[1], 10);
+  const minor = m[2] ? parseInt(m[2], 10) : 0;
+  return major * 1000 + minor;
+}
+
+async function main() {
+  const MODELS = await loadPiModels();
+
+  const out: Record<string, { id: string; label: string }[]> = {};
+  let total = 0;
+  for (const [blobyId, piKey] of Object.entries(PROVIDER_MAP)) {
+    const provider = MODELS[piKey];
+    if (!provider) {
+      console.warn(`!  no pi provider "${piKey}" (mapped from bloby "${blobyId}")`);
+      continue;
+    }
+    const entries: { id: string; label: string }[] = [];
+    for (const [id, m] of Object.entries(provider)) {
+      if (isHidden(id)) continue;
+      entries.push({ id, label: m?.name || id });
+    }
+    // Newest version first; alphabetical inside the same version.
+    entries.sort((a, b) => {
+      const dv = versionScore(b.id) - versionScore(a.id);
+      return dv !== 0 ? dv : a.id.localeCompare(b.id);
+    });
+    out[blobyId] = entries;
+    total += entries.length;
+  }
+
+  const banner =
+    `// Auto-generated by scripts/sync-pi-models.ts — DO NOT EDIT MANUALLY.\n` +
+    `// Source: earendil-works/pi @ packages/ai/src/models.generated.ts\n` +
+    `// Last sync: ${new Date().toISOString()}\n` +
+    `\n`;
+  const body =
+    `export interface PiCatalogModel { id: string; label: string }\n` +
+    `export const PI_MODELS_CATALOG: Record<string, PiCatalogModel[]> = ${JSON.stringify(out, null, 2)};\n`;
+  fs.writeFileSync(OUTPUT_PATH, banner + body);
+
+  console.log(`✓ wrote ${OUTPUT_PATH}`);
+  console.log(`  ${Object.keys(out).length} providers, ${total} models`);
+  for (const [k, v] of Object.entries(out)) {
+    console.log(`  · ${k}: ${v.length}`);
+  }
+}
+
+main().catch((err) => {
+  console.error('✗ sync failed:', err);
+  process.exit(1);
+});

package/shared/config.ts

@@ -17,7 +17,7 @@ export interface BotConfig {
   port: number;
   username: string;
   ai: {
-    provider: 'openai' | 'anthropic' | 'ollama' | '';
+    provider: 'openai' | 'anthropic' | 'ollama' | 'pi' | '';
     model: string;
     apiKey: string;
     baseUrl?: string;

package/supervisor/bloby-agent.ts

@@ -17,6 +17,7 @@
 
 import * as claude from './harnesses/claude.js';
 import * as codex from './harnesses/codex.js';
+import * as pi from './harnesses/pi/index.js';
 import type { Harness, OnAgentMessage, RecentMessage, AgentAttachment, AgentQueryRequest, AgentQueryResult } from './harnesses/types.js';
 import type { SavedFile } from './file-saver.js';
 import { loadConfig } from '../shared/config.js';
@@ -26,6 +27,7 @@ export type { RecentMessage, AgentAttachment, AgentQueryRequest, AgentQueryResul
 const HARNESSES: Record<string, Harness> = {
   anthropic: claude,
   openai: codex,
+  pi: pi as unknown as Harness,
 };
 
 /** Resolve the harness for the currently-configured provider. */

package/supervisor/harnesses/pi/async-queue.ts

@@ -0,0 +1,45 @@
+/**
+ * Async input queue — copy of the helper from `harnesses/claude.ts:37-68`.
+ *
+ * The Claude harness uses this exact shape as the input prompt to the Claude
+ * Agent SDK's long-lived `query()`. The pi session loop uses the same pattern
+ * so the non-blocking live-conversation behavior matches Claude byte-for-byte
+ * at the queue level: pushMessage() never awaits the model.
+ */
+export interface AsyncQueue<T> extends AsyncIterable<T> {
+  push(item: T): void;
+  end(): void;
+}
+
+export function createAsyncQueue<T>(): AsyncQueue<T> {
+  const pending: T[] = [];
+  let resolve: ((value: IteratorResult<T>) => void) | null = null;
+  let done = false;
+
+  return {
+    push(item: T) {
+      if (done) return;
+      if (resolve) {
+        resolve({ value: item, done: false });
+        resolve = null;
+      } else {
+        pending.push(item);
+      }
+    },
+    end() {
+      done = true;
+      if (resolve) resolve({ value: undefined as any, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return {
+        next(): Promise<IteratorResult<T>> {
+          if (pending.length > 0) {
+            return Promise.resolve({ value: pending.shift()!, done: false });
+          }
+          if (done) return Promise.resolve({ value: undefined as any, done: true });
+          return new Promise((r) => { resolve = r; });
+        },
+      };
+    },
+  };
+}