bloby-bot 0.46.3 → 0.47.1

package/supervisor/chat/OnboardWizard.tsx

@@ -46,6 +46,7 @@ const ACCESS_LABELS: Record<AccessMethod, string> = {
 /* ── Provider config ── */
 
 const PROVIDERS = [
+  { id: 'pi', name: 'Bloby', subtitle: 'Built on top of Pi — bring your own model', icon: '/bloby-icon-192.png' },
   { id: 'anthropic', name: 'Claude', subtitle: 'by Anthropic', icon: '/icons/claude.png' },
   { id: 'openai', name: 'OpenAI Codex', subtitle: 'ChatGPT Plus / Pro', icon: '/icons/codex.png' },
 ] as const;
@@ -171,8 +172,34 @@ export default function OnboardWizard({ onComplete, isInitialSetup = false, onSa
   const [authState, setAuthState] = useState<Record<string, 'idle' | 'authenticating' | 'connected'>>({
     anthropic: 'idle',
     openai: 'idle',
+    pi: 'idle',
   });
 
+  /* ── Bloby (pi) state ── */
+  interface PiSubProviderInfo {
+    id: string;
+    name: string;
+    subtitle: string;
+    flavor: string;
+    baseUrl?: string;
+    needsBaseUrl: boolean;
+    needsApiKey: boolean;
+    apiKeyUrl?: string;
+    models: { id: string; label: string }[] | 'dynamic';
+    defaultModel?: string;
+  }
+  const [piSubProviders, setPiSubProviders] = useState<PiSubProviderInfo[]>([]);
+  const [piSubProvider, setPiSubProvider] = useState<string>('');
+  const [piApiKey, setPiApiKey] = useState('');
+  const [piBaseUrl, setPiBaseUrl] = useState('');
+  const [piModelId, setPiModelId] = useState('');
+  const [piShowKey, setPiShowKey] = useState(false);
+  const [piConnecting, setPiConnecting] = useState(false);
+  const [piError, setPiError] = useState<string | undefined>();
+  const [piTestRunning, setPiTestRunning] = useState(false);
+  const [piTestResult, setPiTestResult] = useState<{ ok: boolean; text?: string; error?: string } | null>(null);
+  const [piSavedStatus, setPiSavedStatus] = useState<{ subProvider?: string; modelId?: string; baseUrl?: string } | null>(null);
+
   // Anthropic/Claude-specific
   const [oauthStarted, setOauthStarted] = useState(false);
   const [anthropicCode, setAnthropicCode] = useState('');
@@ -572,6 +599,130 @@ export default function OnboardWizard({ onComplete, isInitialSetup = false, onSa
     setCodexVerificationUrl('');
     setCodexFlow('device');
     setOpenaiError(undefined);
+    // Pi flow cleanup is per-sub-provider; the load effect handles re-hydration.
+    setPiError(undefined);
+    setPiTestResult(null);
+  };
+
+  /* ── Bloby (pi) handlers ── */
+
+  // Load the sub-provider catalog + saved status when the user picks Bloby
+  useEffect(() => {
+    if (provider !== 'pi') return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const [provRes, statusRes] = await Promise.all([
+          fetch('/api/auth/pi/providers'),
+          fetch('/api/auth/pi/status'),
+        ]);
+        const provData = await provRes.json();
+        const statusData = await statusRes.json();
+        if (cancelled) return;
+        const list: PiSubProviderInfo[] = provData?.providers || [];
+        setPiSubProviders(list);
+        if (statusData?.configured) {
+          setPiSubProvider(statusData.subProvider || '');
+          setPiModelId(statusData.modelId || '');
+          setPiBaseUrl(statusData.baseUrl || '');
+          setAuthState((s) => ({ ...s, pi: 'connected' }));
+          setPiSavedStatus({ subProvider: statusData.subProvider, modelId: statusData.modelId, baseUrl: statusData.baseUrl });
+          setModel(`${statusData.subProvider}/${statusData.modelId || ''}`);
+        } else if (!piSubProvider && list[0]) {
+          setPiSubProvider(list[0].id);
+          setPiBaseUrl(list[0].baseUrl || '');
+          setPiModelId(list[0].defaultModel || '');
+        }
+      } catch (err: any) {
+        if (!cancelled) setPiError(err?.message || 'Failed to load Bloby providers');
+      }
+    })();
+    return () => { cancelled = true; };
+  }, [provider]);
+
+  const selectedPiSub = piSubProviders.find((p) => p.id === piSubProvider);
+
+  const choosePiSubProvider = (id: string) => {
+    const next = piSubProviders.find((p) => p.id === id);
+    setPiSubProvider(id);
+    setPiBaseUrl(next?.baseUrl || '');
+    setPiModelId(next?.defaultModel || '');
+    setPiError(undefined);
+    setPiTestResult(null);
+    // Picking a new sub-provider invalidates the previously saved auth.
+    if (authState.pi === 'connected') {
+      setAuthState((s) => ({ ...s, pi: 'idle' }));
+      setPiSavedStatus(null);
+    }
+  };
+
+  const handlePiConnect = async () => {
+    if (!piSubProvider) return;
+    setPiError(undefined);
+    setPiTestResult(null);
+    setPiConnecting(true);
+    try {
+      const payload = {
+        subProvider: piSubProvider,
+        apiKey: piApiKey.trim() || undefined,
+        baseUrl: piBaseUrl.trim() || undefined,
+        modelId: piModelId.trim() || undefined,
+      };
+      const testRes = await fetch('/api/auth/pi/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      const testData = await testRes.json();
+      if (!testData?.ok) {
+        setPiError(testData?.error || 'Connection test failed');
+        return;
+      }
+      const saveRes = await fetch('/api/auth/pi/save', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      const saveData = await saveRes.json();
+      if (!saveData?.ok) {
+        setPiError(saveData?.error || 'Failed to save credentials');
+        return;
+      }
+      setAuthState((s) => ({ ...s, pi: 'connected' }));
+      setPiSavedStatus(saveData.status || null);
+      setModel(`${piSubProvider}/${piModelId || selectedPiSub?.defaultModel || ''}`);
+      setPiApiKey('');
+    } catch (err: any) {
+      setPiError(err?.message || 'Connection failed');
+    } finally {
+      setPiConnecting(false);
+    }
+  };
+
+  const handlePiDisconnect = async () => {
+    try { await fetch('/api/auth/pi', { method: 'DELETE' }); } catch {}
+    setAuthState((s) => ({ ...s, pi: 'idle' }));
+    setPiSavedStatus(null);
+    setPiTestResult(null);
+    setModel('');
+  };
+
+  const handlePiTestCompletion = async () => {
+    setPiTestRunning(true);
+    setPiTestResult(null);
+    try {
+      const res = await fetch('/api/auth/pi/completion', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({}),
+      });
+      const data = await res.json();
+      setPiTestResult({ ok: !!data?.ok, text: data?.text, error: data?.error });
+    } catch (err: any) {
+      setPiTestResult({ ok: false, error: err?.message || 'Request failed' });
+    } finally {
+      setPiTestRunning(false);
+    }
   };
 
   /* ── Auth handlers: Anthropic/Claude ── */
@@ -2090,6 +2241,180 @@ export default function OnboardWizard({ onComplete, isInitialSetup = false, onSa
 
                 <div className="border-t border-white/[0.06] mt-4 mb-3" />
 
+                {/* ── Auth flow: Bloby (pi) ── */}
+                {provider === 'pi' && (
+                  <div className="space-y-3">
+                    {authState.pi === 'connected' && piSavedStatus ? (
+                      <>
+                        <div className="bg-emerald-500/8 border border-emerald-500/15 rounded-lg px-3.5 py-2.5">
+                          <p className="text-emerald-400/90 text-[12px]">
+                            Connected — {piSubProviders.find((p) => p.id === piSavedStatus.subProvider)?.name || piSavedStatus.subProvider}
+                            {piSavedStatus.modelId ? <> · <span className="font-mono">{piSavedStatus.modelId}</span></> : null}
+                          </p>
+                        </div>
+
+                        <div className="bg-white/[0.03] border border-white/[0.06] rounded-xl p-3.5 space-y-2.5">
+                          <p className="text-[12px] text-white/55">
+                            Send a quick test request to confirm the model is reachable.
+                          </p>
+                          <button
+                            onClick={handlePiTestCompletion}
+                            disabled={piTestRunning}
+                            className="w-full py-2 px-4 bg-white/[0.06] hover:bg-white/[0.1] text-white text-[12px] font-medium rounded-xl transition-colors flex items-center justify-center gap-2 disabled:opacity-60"
+                          >
+                            {piTestRunning ? (
+                              <><LoaderCircle className="h-3.5 w-3.5 animate-spin" />Sending test request…</>
+                            ) : (
+                              <>Send test request<ArrowRight className="h-3.5 w-3.5 opacity-60" /></>
+                            )}
+                          </button>
+                          {piTestResult && piTestResult.ok && (
+                            <div className="bg-emerald-500/5 border border-emerald-500/15 rounded-lg px-3 py-2">
+                              <p className="text-[11px] text-emerald-400/70 mb-1">Model reply</p>
+                              <p className="text-[12px] text-white/85 whitespace-pre-wrap">{piTestResult.text}</p>
+                            </div>
+                          )}
+                          {piTestResult && !piTestResult.ok && (
+                            <div className="bg-red-500/8 border border-red-500/15 rounded-lg px-3 py-2">
+                              <p className="text-[12px] text-red-400/90">{piTestResult.error}</p>
+                            </div>
+                          )}
+                        </div>
+
+                        <button
+                          onClick={handlePiDisconnect}
+                          className="w-full py-1.5 text-white/25 text-[11px] hover:text-white/40 transition-colors flex items-center justify-center gap-1.5"
+                        >
+                          <RefreshCw className="h-3 w-3" />
+                          Use a different model
+                        </button>
+                      </>
+                    ) : (
+                      <>
+                        <div>
+                          <p className="text-[12px] text-white/40 mb-2">Pick an LLM provider — Bloby brings your own model.</p>
+                          <div className="grid grid-cols-2 gap-2 max-h-[320px] overflow-y-auto pr-1">
+                            {piSubProviders.map((sp) => (
+                              <button
+                                key={sp.id}
+                                type="button"
+                                onClick={() => choosePiSubProvider(sp.id)}
+                                className={`relative text-left rounded-xl border px-3 py-2.5 transition-colors ${
+                                  piSubProvider === sp.id
+                                    ? 'border-[#AF27E3]/50 bg-[#AF27E3]/10'
+                                    : 'border-white/[0.08] bg-white/[0.02] hover:bg-white/[0.04]'
+                                }`}
+                              >
+                                <p className="text-[12.5px] text-white font-medium leading-tight">{sp.name}</p>
+                                <p className="text-[10.5px] text-white/40 mt-0.5 leading-tight">{sp.subtitle}</p>
+                                {piSubProvider === sp.id && (
+                                  <div className="absolute top-1.5 right-1.5 w-1.5 h-1.5 rounded-full bg-gradient-brand" />
+                                )}
+                              </button>
+                            ))}
+                          </div>
+                        </div>
+
+                        {selectedPiSub && (
+                          <div className="space-y-2 pt-1">
+                            {(selectedPiSub.needsBaseUrl || selectedPiSub.flavor === 'openai-completions') && (
+                              <div>
+                                <label className="text-[11px] text-white/40 font-medium mb-1 block">
+                                  Base URL{selectedPiSub.needsBaseUrl ? '' : ' (override — optional)'}
+                                </label>
+                                <input
+                                  type="text"
+                                  value={piBaseUrl}
+                                  onChange={(e) => setPiBaseUrl(e.target.value)}
+                                  placeholder={selectedPiSub.baseUrl || 'https://example.com/v1'}
+                                  className={inputSmCls + ' font-mono'}
+                                />
+                              </div>
+                            )}
+
+                            {selectedPiSub.needsApiKey && (
+                              <div>
+                                <label className="text-[11px] text-white/40 font-medium mb-1 block flex items-center justify-between">
+                                  <span>API key</span>
+                                  {selectedPiSub.apiKeyUrl && (
+                                    <button
+                                      type="button"
+                                      onClick={() => openExternal(selectedPiSub.apiKeyUrl!)}
+                                      className="text-white/30 hover:text-white/60 text-[10.5px] flex items-center gap-1"
+                                    >
+                                      Get a key <ExternalLink className="h-3 w-3" />
+                                    </button>
+                                  )}
+                                </label>
+                                <div className="relative">
+                                  <input
+                                    type={piShowKey ? 'text' : 'password'}
+                                    value={piApiKey}
+                                    onChange={(e) => setPiApiKey(e.target.value)}
+                                    onKeyDown={(e) => e.key === 'Enter' && handlePiConnect()}
+                                    placeholder="sk-..."
+                                    className={inputSmCls + ' pr-10 font-mono'}
+                                  />
+                                  <button
+                                    type="button"
+                                    onClick={() => setPiShowKey((v) => !v)}
+                                    className="absolute right-3 top-1/2 -translate-y-1/2 text-white/20 hover:text-white/50 transition-colors"
+                                  >
+                                    {piShowKey ? <EyeOff className="h-3.5 w-3.5" /> : <Eye className="h-3.5 w-3.5" />}
+                                  </button>
+                                </div>
+                              </div>
+                            )}
+
+                            <div>
+                              <label className="text-[11px] text-white/40 font-medium mb-1 block">Model</label>
+                              {Array.isArray(selectedPiSub.models) ? (
+                                <ModelDropdown
+                                  models={selectedPiSub.models}
+                                  value={piModelId}
+                                  onChange={setPiModelId}
+                                />
+                              ) : (
+                                <input
+                                  type="text"
+                                  value={piModelId}
+                                  onChange={(e) => setPiModelId(e.target.value)}
+                                  placeholder={selectedPiSub.defaultModel || 'model-id'}
+                                  className={inputSmCls + ' font-mono'}
+                                />
+                              )}
+                            </div>
+
+                            {piError && (
+                              <div className="bg-red-500/8 border border-red-500/15 rounded-lg px-3 py-2">
+                                <p className="text-[12px] text-red-400/90 break-words">{piError}</p>
+                              </div>
+                            )}
+
+                            <button
+                              onClick={handlePiConnect}
+                              disabled={
+                                piConnecting ||
+                                !piSubProvider ||
+                                (selectedPiSub.needsApiKey && !piApiKey.trim()) ||
+                                (selectedPiSub.needsBaseUrl && !piBaseUrl.trim()) ||
+                                !piModelId.trim()
+                              }
+                              className="w-full py-2.5 px-4 bg-gradient-brand hover:opacity-90 text-white text-[13px] font-medium rounded-xl transition-colors flex items-center justify-center gap-2 disabled:opacity-40"
+                            >
+                              {piConnecting ? (
+                                <><LoaderCircle className="h-3.5 w-3.5 animate-spin" />Connecting…</>
+                              ) : (
+                                <>Test &amp; connect<ArrowRight className="h-3.5 w-3.5 opacity-60" /></>
+                              )}
+                            </button>
+                          </div>
+                        )}
+                      </>
+                    )}
+                  </div>
+                )}
+
                 {/* ── Auth flow: Anthropic ── */}
                 {provider === 'anthropic' && (
                   <div className="space-y-2.5">
@@ -2363,8 +2688,8 @@ export default function OnboardWizard({ onComplete, isInitialSetup = false, onSa
                   </div>
                 )}
 
-                {/* ── Model dropdown (after auth) ── */}
-                {isConnected && (
+                {/* ── Model dropdown (after auth) — pi flow renders its own model picker inside its block ── */}
+                {isConnected && provider !== 'pi' && (
                   <>
                     <div className="border-t border-white/[0.06] mt-4 mb-3" />
                     <label className="text-[12px] text-white/40 font-medium mb-1.5 block">

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; });
+        },
+      };
+    },
+  };
+}

package/supervisor/harnesses/pi/auth-storage.ts

@@ -0,0 +1,56 @@
+/**
+ * Pi auth storage — persistent credentials for the Bloby (pi) harness.
+ *
+ * Stored in ~/.bloby/pi-auth.json (separate from the main config.json so we
+ * can wipe/rotate the LLM credentials without touching the rest of the bot
+ * config). Iteration 1: a single active sub-provider at a time.
+ */
+import fs from 'fs';
+import path from 'path';
+import { DATA_DIR } from '../../../shared/paths.js';
+
+export interface PiAuth {
+  subProvider: string;
+  apiKey?: string;
+  baseUrl?: string;
+  modelId?: string;
+  savedAt: number;
+}
+
+const PI_AUTH_PATH = path.join(DATA_DIR, 'pi-auth.json');
+
+export function readPiAuth(): PiAuth | null {
+  try {
+    if (!fs.existsSync(PI_AUTH_PATH)) return null;
+    const raw = fs.readFileSync(PI_AUTH_PATH, 'utf-8');
+    const parsed = JSON.parse(raw);
+    if (!parsed?.subProvider) return null;
+    return parsed as PiAuth;
+  } catch {
+    return null;
+  }
+}
+
+export function writePiAuth(auth: Omit<PiAuth, 'savedAt'>): PiAuth {
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  const full: PiAuth = { ...auth, savedAt: Date.now() };
+  fs.writeFileSync(PI_AUTH_PATH, JSON.stringify(full, null, 2), { mode: 0o600 });
+  return full;
+}
+
+export function clearPiAuth(): void {
+  try {
+    fs.rmSync(PI_AUTH_PATH, { force: true });
+  } catch {}
+}
+
+export function getPiAuthStatus(): { configured: boolean; subProvider?: string; modelId?: string; baseUrl?: string } {
+  const auth = readPiAuth();
+  if (!auth) return { configured: false };
+  return {
+    configured: true,
+    subProvider: auth.subProvider,
+    modelId: auth.modelId,
+    baseUrl: auth.baseUrl,
+  };
+}