@yeaft/webchat-agent 0.1.872 → 0.1.874

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.872",
+  "version": "0.1.874",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/providers/copilot-models.js

@@ -1,26 +1,26 @@
 /**
  * Copilot model list.
  *
- * The Copilot CLI accepts `--model <id>` and the agent-facing API exposes
- * `GET https://api.githubcopilot.com/models` — the same endpoint VS Code's
- * model picker uses. We hit it on demand (cached in-process for 10 min),
- * filter to picker-enabled chat models, and fall back to a curated static
- * list if the network call fails (so the UI never shows an empty picker).
+ * Source of truth (in order): another module can prime the in-process cache
+ * by calling `cacheCopilotModelsFromAcp(availableModels)` after a successful
+ * `session/new` — that response carries the full model list the CLI itself
+ * would show in its `/model` picker, including pricing/usage metadata. If
+ * the cache is cold when `listCopilotModels()` is called (e.g. the model
+ * picker is opened before any Copilot conversation has started), we spawn
+ * a one-shot `copilot --acp` child, do the `initialize` + `session/new`
+ * handshake to get the same list, then close. Falls back to a static curated
+ * list if even that fails.
  *
- * Auth re-uses the existing `agent/yeaft/llm/credentials/github-copilot.js`
- * credential pipeline — gh CLI / env / persisted OAuth all work; the user
- * does not need to paste an API key as long as Copilot CLI is logged in.
+ * Why ACP and not the HTTP `/models` endpoint: the HTTP endpoint is gated
+ * by org policy on enterprise accounts and frequently returns only legacy
+ * models. ACP `session/new` always returns the real per-account picker list.
  */
 
-import { getApiToken, copilotRequestHeaders, validateRawToken, resolveRawToken } from '../yeaft/llm/credentials/github-copilot.js';
-import { readFile } from 'fs/promises';
-import { homedir } from 'os';
-import { join } from 'path';
+import { spawn } from 'child_process';
+import { AcpClient } from './acp-client.js';
 
-// Curated fallback — mirrors the CLI's own hardcoded default model list
-// (`jF` in @github/copilot/app.js@1.0.59). Used when /models is unavailable
-// or when org policy hides the picker list at the API (some enterprise orgs
-// gate it). `--model <id>` still accepts these IDs at chat time.
+// Curated fallback — last resort if no ACP cache and no live probe works.
+// Vendor inferred from id prefix when missing.
 export const FALLBACK_COPILOT_MODELS = Object.freeze([
   { id: 'claude-sonnet-4.6',  label: 'Claude Sonnet 4.6', vendor: 'Anthropic' },
   { id: 'claude-sonnet-4.5',  label: 'Claude Sonnet 4.5', vendor: 'Anthropic' },
@@ -32,7 +32,6 @@ export const FALLBACK_COPILOT_MODELS = Object.freeze([
   { id: 'gpt-5.5',            label: 'GPT-5.5',           vendor: 'OpenAI'    },
   { id: 'gpt-5.4',            label: 'GPT-5.4',           vendor: 'OpenAI'    },
   { id: 'gpt-5.3-codex',      label: 'GPT-5.3 Codex',     vendor: 'OpenAI'    },
-  { id: 'gpt-5.2-codex',      label: 'GPT-5.2 Codex',     vendor: 'OpenAI'    },
   { id: 'gpt-5.2',            label: 'GPT-5.2',           vendor: 'OpenAI'    },
   { id: 'gpt-5.4-mini',       label: 'GPT-5.4 Mini',      vendor: 'OpenAI'    },
   { id: 'gpt-5-mini',         label: 'GPT-5 Mini',        vendor: 'OpenAI'    },
@@ -41,58 +40,93 @@ export const FALLBACK_COPILOT_MODELS = Object.freeze([
 
 export const DEFAULT_COPILOT_MODEL = 'claude-sonnet-4.5';
 
-const MODELS_ENDPOINT = 'https://api.githubcopilot.com/models';
-const CACHE_TTL_MS = 10 * 60 * 1000;
-const COPILOT_CLI_CONFIG = join(homedir(), '.copilot', 'config.json');
+const CACHE_TTL_MS = 30 * 60 * 1000;
+const PROBE_TIMEOUT_MS = 8000;
+
+let _cache = null; // { models, fetchedAt }
+let _inflight = null;
+
+function _vendorFromId(id) {
+  const s = String(id || '').toLowerCase();
+  if (s.startsWith('claude')) return 'Anthropic';
+  if (s.startsWith('gpt') || s.startsWith('o1') || s.startsWith('o3') || s.startsWith('chatgpt')) return 'OpenAI';
+  if (s.startsWith('gemini')) return 'Google';
+  return '';
+}
+
+function _normalizeAcpModel(m) {
+  if (!m || !m.modelId) return null;
+  // Skip "auto" sentinel — not a real model, just a router placeholder.
+  if (m.modelId === 'auto') return null;
+  const meta = m._meta || {};
+  return {
+    id: m.modelId,
+    label: m.name || m.modelId,
+    vendor: _vendorFromId(m.modelId),
+    usage: meta.copilotUsage || '',              // "1x" / "0.33x" / "15x"
+    priceCategory: meta.copilotPriceCategory || '', // "low" / "medium" / "high"
+    enablement: meta.copilotEnablement || '',    // "enabled" / "disabled"
+  };
+}
 
 /**
- * Last-resort token source: the Copilot CLI itself caches an OAuth token at
- * ~/.copilot/config.json after `copilot login`. If the standard yeaft
- * credential pipeline (env / gh CLI / persisted device flow) didn't surface
- * a token, we re-use the CLI's. Same auth surface — no extra perm needed.
+ * Prime the in-process cache from an ACP `session/new` response (preferred).
+ * Called from copilot.js after a successful handshake.
  */
-async function _resolveCopilotCliToken() {
-  try {
-    const raw = await readFile(COPILOT_CLI_CONFIG, 'utf8');
-    // Copilot CLI's config.json starts with `//` comments. Strip line comments
-    // before JSON.parse — the file otherwise has no string-context `//`.
-    const cleaned = raw.split('\n').filter(l => !l.trim().startsWith('//')).join('\n');
-    const cfg = JSON.parse(cleaned);
-    const tokens = cfg?.copilotTokens && typeof cfg.copilotTokens === 'object' ? cfg.copilotTokens : null;
-    if (!tokens) return null;
-    for (const tok of Object.values(tokens)) {
-      if (typeof tok === 'string' && validateRawToken(tok).valid) return tok;
-    }
-    return null;
-  } catch {
-    return null;
-  }
+export function cacheCopilotModelsFromAcp(availableModels) {
+  if (!Array.isArray(availableModels)) return;
+  const models = availableModels.map(_normalizeAcpModel).filter(Boolean);
+  if (!models.length) return;
+  _cache = { models, fetchedAt: Date.now() };
 }
 
-async function _resolveBearerToken() {
-  // The /models endpoint accepts the GitHub OAuth token directly as a Bearer
-  // — no token exchange needed (unlike the chat-completion endpoints). So we
-  // prefer the raw OAuth from the standard yeaft pipeline first, then fall
-  // back to the Copilot CLI's own cached OAuth at ~/.copilot/config.json.
-  try {
-    const raw = await resolveRawToken();
-    if (raw?.token) return raw.token;
-  } catch { /* fall through */ }
-  const cliRaw = await _resolveCopilotCliToken();
-  if (cliRaw) return cliRaw;
-  // Last resort: try exchanged token (works for chat endpoints; may also work
-  // if /models gained that auth path in future).
-  const cred = await getApiToken();
-  return cred?.token || null;
-}
+/**
+ * Spawn a short-lived `copilot --acp` child, do initialize + session/new,
+ * pull `models.availableModels` out of the response, then close. Times out
+ * after PROBE_TIMEOUT_MS. Resolves to an array (possibly empty) or rejects.
+ */
+function _probeAcpModels() {
+  return new Promise((resolve, reject) => {
+    let child;
+    let client;
+    let done = false;
+    const finish = (err, models) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      try { client?.close(); } catch {}
+      try { child?.kill('SIGTERM'); } catch {}
+      if (err) reject(err); else resolve(models || []);
+    };
+    try {
+      child = spawn('copilot', ['--acp'], { stdio: ['pipe', 'pipe', 'pipe'] });
+    } catch (e) { return reject(e); }
+    const timer = setTimeout(() => finish(new Error('ACP probe timeout')), PROBE_TIMEOUT_MS);
+    child.on('error', (e) => finish(e));
+    child.on('exit', () => finish(new Error('ACP child exited')));
+    child.stderr.on('data', () => { /* swallow */ });
 
-let _cache = null; // { models, fetchedAt }
-let _inflight = null; // dedupes concurrent cold-cache calls
+    client = new AcpClient({
+      stdin: child.stdin,
+      stdout: child.stdout,
+      onError: (e) => finish(e),
+    });
+
+    (async () => {
+      try {
+        await client.request('initialize', { protocolVersion: 1, clientCapabilities: {} });
+        const r = await client.request('session/new', { cwd: process.cwd(), mcpServers: [] });
+        finish(null, r?.models?.availableModels || []);
+      } catch (e) {
+        finish(e);
+      }
+    })();
+  });
+}
 
 /**
- * Returns a list of `{id, label, vendor, preview, family}` records,
- * picker-enabled chat models only. Cached for 10 minutes. Never throws —
- * falls back to the static list on any error (including network timeout).
+ * Returns picker-enabled chat models for the signed-in Copilot account.
+ * Cache for 30 min. Never throws — falls back to the curated static list.
  */
 export async function listCopilotModels({ force = false } = {}) {
   if (!force && _cache && Date.now() - _cache.fetchedAt < CACHE_TTL_MS) {
@@ -100,35 +134,15 @@ export async function listCopilotModels({ force = false } = {}) {
   }
   if (_inflight) return (await _inflight).slice();
   _inflight = (async () => {
-    const ac = new AbortController();
-    const timer = setTimeout(() => ac.abort(), 5000);
     try {
-      const token = await _resolveBearerToken();
-      if (!token) return FALLBACK_COPILOT_MODELS.slice();
-      const res = await fetch(MODELS_ENDPOINT, {
-        signal: ac.signal,
-        headers: { ...copilotRequestHeaders({ isAgentTurn: false }), Authorization: `Bearer ${token}` },
-      });
-      if (!res.ok) return FALLBACK_COPILOT_MODELS.slice();
-      const body = await res.json();
-      const data = Array.isArray(body?.data) ? body.data : [];
-      const models = data
-        .filter(m => m && m.model_picker_enabled && m.capabilities?.type === 'chat')
-        .map(m => ({
-          id: m.id,
-          label: m.name || m.id,
-          vendor: m.vendor || '',
-          preview: !!m.preview,
-          family: m.capabilities?.family || '',
-        }));
-      if (!models.length) return FALLBACK_COPILOT_MODELS.slice();
-      _cache = { models, fetchedAt: Date.now() };
-      return models.slice();
-    } catch {
-      return FALLBACK_COPILOT_MODELS.slice();
-    } finally {
-      clearTimeout(timer);
-    }
+      const acpModels = await _probeAcpModels();
+      const models = acpModels.map(_normalizeAcpModel).filter(Boolean);
+      if (models.length) {
+        _cache = { models, fetchedAt: Date.now() };
+        return models;
+      }
+    } catch { /* fall through to static */ }
+    return FALLBACK_COPILOT_MODELS.slice();
   })();
   try {
     return (await _inflight).slice();
@@ -139,3 +153,5 @@ export async function listCopilotModels({ force = false } = {}) {
 
 /** Tests only. */
 export function _resetCopilotModelsCacheForTests() { _cache = null; _inflight = null; }
+/** Tests only. */
+export function _normalizeAcpModelForTests(m) { return _normalizeAcpModel(m); }

package/providers/copilot.js

@@ -6,7 +6,7 @@ import { join } from 'path';
 import { DatabaseSync } from 'node:sqlite';
 import ctx from '../context.js';
 import { AcpClient } from './acp-client.js';
-import { listCopilotModels, DEFAULT_COPILOT_MODEL } from './copilot-models.js';
+import { listCopilotModels, DEFAULT_COPILOT_MODEL, cacheCopilotModelsFromAcp } from './copilot-models.js';
 
 export const name = 'copilot';
 
@@ -179,6 +179,7 @@ async function _bootAcp(state, resumeSessionId, model) {
     state.sessionId = resumeSessionId;
     state.claudeSessionId = resumeSessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
+    if (Array.isArray(r?.models?.availableModels)) cacheCopilotModelsFromAcp(r.models.availableModels);
   } else {
     if (resumeSessionId && !state.acpCapabilities.loadSession) {
       // Surface the downgrade — silently handing back a fresh session would
@@ -196,6 +197,7 @@ async function _bootAcp(state, resumeSessionId, model) {
     state.sessionId = r?.sessionId || randomUUID();
     state.claudeSessionId = state.sessionId;
     if (Array.isArray(r?.modes?.availableModes)) state.acpModes = r.modes.availableModes;
+    if (Array.isArray(r?.models?.availableModels)) cacheCopilotModelsFromAcp(r.models.availableModels);
   }
 
   // 3) Emit a system_init envelope so the UI populates tools / model panels.

package/yeaft/init.js

@@ -8,9 +8,10 @@
 import { existsSync, mkdirSync, writeFileSync, accessSync, constants } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-// NOTE: migrateSessionsV1 is imported by tests directly from
-// './migrate/sessions-v1.js' — not wired into initYeaftDir() yet (Phase 2
-// will activate it once the runtime reads from sessions/).
+// NOTE: migrateSessionsV1 is called at the end of initYeaftDir() to collapse
+// any legacy groups/ + chats/ + memory/{group,chat}/ data into the unified
+// sessions/ layout. Idempotent via sentinel file.
+import { migrateSessionsV1 } from './migrate/sessions-v1.js';
 
 /**
  * Check if an error is a permission error (EACCES or EPERM).
@@ -221,5 +222,20 @@ export function initYeaftDir(dir) {
   // from under the live group/chat code paths. Phase 2 flips the runtime
   // and then hooks `migrateSessionsV1(root)` here.
 
+  // NOTE: sessions-v1 migration runs at end. Fire-and-log: keep
+  // initYeaftDir() sync so existing callers don't break. The migration is
+  // idempotent (sentinel file) so a partial run on crash is safe.
+  Promise.resolve()
+    .then(() => migrateSessionsV1(root))
+    .then((res) => {
+      if (res && res.migrated) {
+        console.log(`[yeaft] session migration complete (${res.moved} dirs moved${res.warnings?.length ? `, ${res.warnings.length} warnings` : ''})`);
+        if (res.warnings?.length) for (const w of res.warnings) console.warn(`[yeaft] migration: ${w}`);
+      }
+    })
+    .catch((err) => {
+      console.warn(`[yeaft] session migration failed (continuing): ${err?.message || err}`);
+    });
+
   return { dir: root, created, writable, warnings };
 }

package/yeaft/migrate/sessions-v1.js

@@ -43,7 +43,7 @@ const SENTINEL = '.session-migration-v1.done';
  * @param {string} yeaftDir
  * @returns {{ migrated: boolean, moved: number, warnings: string[] }}
  */
-export function migrateSessionsV1(yeaftDir) {
+export async function migrateSessionsV1(yeaftDir) {
   const warnings = [];
   if (!yeaftDir || !existsSync(yeaftDir)) {
     return { migrated: false, moved: 0, warnings: ['yeaftDir missing'] };
@@ -172,13 +172,32 @@ export function migrateSessionsV1(yeaftDir) {
     }
   }
 
-  // 6. sentinel
-  //
-  // PHASE 2 TODO: the SQLite FTS index (memory/index-db.js) still has rows
-  // pointing at group/<id> and chat/<id> scopes after this migration. When
-  // Phase 2 activates this migration from initYeaftDir(), it MUST also
-  // delete or rebuild the FTS index so the new session/<id> scopes get
-  // re-indexed. Preflow recall is broken until then.
+  // 6. Rewrite SQLite FTS index scope strings via the shared index-db
+  //    module (which already handles ABI loading). Idempotent: WHERE clause
+  //    skips already-rewritten rows.
+  try {
+    const dbPath = join(memoryRoot, 'index.db');
+    if (existsSync(dbPath)) {
+      const { openSegmentIndex } = await import('../memory/index-db.js');
+      const idx = openSegmentIndex(dbPath);
+      try {
+        const db = idx._db;
+        db.exec("BEGIN");
+        db.exec("UPDATE memory_segments SET scope = REPLACE(scope, 'group/', 'session/') WHERE scope LIKE 'group/%'");
+        db.exec("UPDATE memory_segments SET scope = REPLACE(scope, 'chat/', 'session/') WHERE scope LIKE 'chat/%'");
+        db.exec("COMMIT");
+      } catch (err) {
+        try { idx._db.exec("ROLLBACK"); } catch { /* ignore */ }
+        warnings.push(`FTS scope rewrite failed: ${err.message}`);
+      } finally {
+        try { idx.close(); } catch { /* ignore */ }
+      }
+    }
+  } catch (err) {
+    warnings.push(`FTS rewrite skipped: ${err.message}`);
+  }
+
+  // 7. sentinel
   writeFileSync(sentinel, JSON.stringify({
     version: 1,
     migratedAt: new Date().toISOString(),