@c4t4/heyamigo 0.8.8 → 0.8.10

package/config/config.example.json

@@ -24,6 +24,10 @@
     "reload": ["reload"]
   },
 
+  "ai": {
+    "provider": "claude"
+  },
+
   "claude": {
     "model": "claude-opus-4-7",
     "personalityFile": "./config/personalities/sharp.md",

package/dist/ai/codex.js

@@ -6,8 +6,8 @@
 // What's wired:
 //   - exec mode with --json (NDJSON event stream on stdout)
 //   - --add-dir for extra writable roots
-//   - --sandbox-mode for tier (read-only / workspace-write / danger-full-access)
-//   - --resume <id> for session continuation
+//   - --sandbox for tier (read-only / workspace-write / danger-full-access)
+//   - `resume <id>` subcommand for session continuation (not a flag)
 //   - prompt passed on stdin (matches the spawn plumbing that already
 //     pipes input to child.stdin)
 //
@@ -41,8 +41,8 @@ function systemPrompt() {
 function reloadSystemPrompt() {
     cachedSystemPrompt = null;
 }
-// Codex sandbox vocabulary. The CLI flag is --sandbox-mode (or --sandbox in
-// some builds); values are: read-only, workspace-write, danger-full-access.
+// Codex sandbox vocabulary. CLI flag is --sandbox; values are: read-only,
+// workspace-write, danger-full-access.
 function sandboxFor(mode) {
     switch (mode) {
         case 'read-only':
@@ -58,11 +58,12 @@ function laneTimeoutMs(lane) {
 }
 function buildExecArgs(params) {
     const args = ['exec', '--json'];
-    args.push('--sandbox-mode', sandboxFor(params.mode));
+    args.push('--sandbox', sandboxFor(params.mode));
     if (params.sessionId) {
-        // Resume keeps the prior conversation; system prompt and add-dirs
-        // were baked in on the original turn.
-        args.push('--resume', params.sessionId);
+        // Resume is a subcommand of exec, not a flag: `codex exec [opts] resume
+        // <SESSION_ID> [prompt]`. System prompt and add-dirs were baked in on
+        // the original turn so we don't re-pass them here.
+        args.push('resume', params.sessionId);
     }
     else {
         for (const dir of params.addDirs ?? []) {

package/dist/ai/sessions.js

@@ -6,6 +6,11 @@ function sessionsPath() {
     return resolve(process.cwd(), config.storage.sessionsFile);
 }
 let sessions = load();
+// Migration from v0.8.x flat format: previously `sessions.json` held either
+// `{ jid: "session-string" }` or `{ jid: { sessionId, usage } }`. Both meant
+// "Claude session for this jid" because Claude was the only provider. We
+// attribute legacy entries to `claude` so existing installs don't lose state
+// when they upgrade.
 function load() {
     const path = sessionsPath();
     if (!existsSync(path))
@@ -15,10 +20,28 @@ function load() {
         const out = {};
         for (const [jid, v] of Object.entries(raw)) {
             if (typeof v === 'string') {
-                out[jid] = { sessionId: v }; // migrate old flat string format
+                // legacy flat string
+                out[jid] = { claude: { sessionId: v } };
             }
-            else if (v && typeof v === 'object' && 'sessionId' in v) {
-                out[jid] = v;
+            else if (v && typeof v === 'object') {
+                const obj = v;
+                // Detect already-namespaced format: at least one key is a known
+                // ProviderName whose value looks like a Session.
+                const isNamespaced = ('claude' in obj &&
+                    typeof obj.claude === 'object' &&
+                    obj.claude !== null &&
+                    'sessionId' in obj.claude) ||
+                    ('codex' in obj &&
+                        typeof obj.codex === 'object' &&
+                        obj.codex !== null &&
+                        'sessionId' in obj.codex);
+                if (isNamespaced) {
+                    out[jid] = obj;
+                }
+                else if ('sessionId' in obj) {
+                    // legacy single-Session shape
+                    out[jid] = { claude: obj };
+                }
             }
         }
         return out;
@@ -33,31 +56,47 @@ function save() {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, JSON.stringify(sessions, null, 2) + '\n', 'utf-8');
 }
-export function getSession(jid) {
-    return sessions[jid]?.sessionId;
+export function getSession(jid, provider) {
+    return sessions[jid]?.[provider]?.sessionId;
 }
-export function getSessionInfo(jid) {
-    return sessions[jid];
+export function getSessionInfo(jid, provider) {
+    return sessions[jid]?.[provider];
 }
-export function setSession(jid, sessionId) {
-    const existing = sessions[jid];
-    sessions[jid] = { sessionId, usage: existing?.usage };
+export function setSession(jid, provider, sessionId) {
+    const bucket = sessions[jid] ?? {};
+    const existing = bucket[provider];
+    bucket[provider] = { sessionId, usage: existing?.usage };
+    sessions[jid] = bucket;
     save();
 }
-export function setUsage(jid, usage) {
-    const existing = sessions[jid];
+export function setUsage(jid, provider, usage) {
+    const existing = sessions[jid]?.[provider];
     if (!existing)
         return;
-    sessions[jid] = { ...existing, usage };
+    const bucket = sessions[jid];
+    bucket[provider] = { ...existing, usage };
     save();
 }
-export function clearSession(jid) {
-    if (!(jid in sessions))
+// Clears the session for one provider on this jid. Returns true if a session
+// was actually removed. Other providers' sessions on the same jid are left
+// alone — they're independent.
+export function clearSession(jid, provider) {
+    const bucket = sessions[jid];
+    if (!bucket || !bucket[provider])
         return false;
-    delete sessions[jid];
+    delete bucket[provider];
+    if (Object.keys(bucket).length === 0) {
+        delete sessions[jid];
+    }
+    else {
+        sessions[jid] = bucket;
+    }
     save();
     return true;
 }
+// Returns every (jid, provider) pair currently stored. Used by the sweeper to
+// discover jids with activity — it doesn't care which provider produced the
+// session id.
 export function listSessions() {
     return sessions;
 }

package/dist/gateway/commands.js

@@ -1,5 +1,5 @@
 import { clearSession, getSessionInfo } from '../ai/sessions.js';
-import { reloadAllSystemPrompts } from '../ai/providers.js';
+import { getProvider, reloadAllSystemPrompts } from '../ai/providers.js';
 import { config } from '../config.js';
 import { runDigestNow } from '../memory/scheduler.js';
 import { sendText } from '../wa/sender.js';
@@ -16,15 +16,16 @@ export async function tryCommand(ctx) {
     if (!cmd)
         return false;
     if (config.commands.reset.includes(cmd)) {
-        const existed = clearSession(ctx.jid);
+        const provider = getProvider();
+        const existed = clearSession(ctx.jid, provider.name);
         const reply = existed
-            ? 'Session reset. Next message will bootstrap a fresh Claude session.'
+            ? `Session reset. Next message will bootstrap a fresh ${provider.name} session.`
             : 'No session to reset.';
         await sendText(ctx.sock, ctx.jid, reply, ctx.quoted);
         return true;
     }
     if (config.commands.status.includes(cmd)) {
-        const info = getSessionInfo(ctx.jid);
+        const info = getSessionInfo(ctx.jid, getProvider().name);
         if (!info) {
             await sendText(ctx.sock, ctx.jid, 'No session yet. Next message will bootstrap one.', ctx.quoted);
             return true;
@@ -42,7 +43,7 @@ export async function tryCommand(ctx) {
     }
     if (config.commands.reload.includes(cmd)) {
         reloadAllSystemPrompts();
-        const existed = clearSession(ctx.jid);
+        const existed = clearSession(ctx.jid, getProvider().name);
         const reply = existed
             ? 'Personality reloaded and session reset.'
             : 'Personality reloaded.';

package/dist/gateway/incoming.js

@@ -1,5 +1,6 @@
 import { unlink } from 'fs/promises';
 import { getContentType, isJidGroup, jidDecode, jidNormalizedUser, } from 'baileys';
+import { getProvider } from '../ai/providers.js';
 import { getSession } from '../ai/sessions.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
@@ -162,7 +163,7 @@ async function processMessages(messages, sock, ownerJid, isHistorySync = false)
                 }
             }
             const { role } = getRoleForContext(stored.senderNumber, isGroup);
-            const existingSession = getSession(stored.jid);
+            const existingSession = getSession(stored.jid, getProvider().name);
             let userContent = stored.text;
             if (media) {
                 const tag = mediaPromptTag(media, stored.text);

package/dist/queue/async-tasks.js

@@ -231,16 +231,31 @@ function truncate(s, n) {
 //   memory of prior tasks across runs.
 // - Task description is added as a new user message to the persistent
 //   session. The worker sees the accumulated history automatically.
-function browserSessionFilePath() {
+// Per-provider browser session storage. Each CLI's session ids are opaque
+// to the other, so swapping providers must not feed one's session id to
+// the other. Filename includes the provider name to keep them separate;
+// the legacy provider-less filename is auto-migrated to claude on read.
+function browserSessionFilePath(provider) {
+    return resolve(process.cwd(), config.memory.dir, `browser-session-${provider}.json`);
+}
+function legacyBrowserSessionFilePath() {
     return resolve(process.cwd(), config.memory.dir, 'browser-session.json');
 }
-function loadBrowserSession() {
-    const path = browserSessionFilePath();
+function loadBrowserSession(provider) {
+    const path = browserSessionFilePath(provider);
+    let source = path;
     if (!existsSync(path)) {
-        return { sessionId: null, createdAt: 0, lastUsedAt: 0, resumeCount: 0 };
+        const legacy = legacyBrowserSessionFilePath();
+        if (provider === 'claude' && existsSync(legacy)) {
+            // One-time migration: legacy file was implicitly claude.
+            source = legacy;
+        }
+        else {
+            return { sessionId: null, createdAt: 0, lastUsedAt: 0, resumeCount: 0 };
+        }
     }
     try {
-        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        const parsed = JSON.parse(readFileSync(source, 'utf-8'));
         return {
             sessionId: parsed.sessionId ?? null,
             createdAt: parsed.createdAt ?? 0,
@@ -252,21 +267,23 @@ function loadBrowserSession() {
         return { sessionId: null, createdAt: 0, lastUsedAt: 0, resumeCount: 0 };
     }
 }
-function saveBrowserSession(state) {
-    const path = browserSessionFilePath();
+function saveBrowserSession(provider, state) {
+    const path = browserSessionFilePath(provider);
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
 }
-// Reset the browser session. Callable from outside if the session gets
-// corrupted or we want a fresh start. Not wired into any command yet.
+// Reset the browser session for the active provider. Callable from outside
+// if the session gets corrupted or we want a fresh start. Not wired into
+// any command yet.
 export function resetBrowserSession() {
-    saveBrowserSession({
+    const provider = getProvider().name;
+    saveBrowserSession(provider, {
         sessionId: null,
         createdAt: 0,
         lastUsedAt: 0,
         resumeCount: 0,
     });
-    logger.info('browser session reset');
+    logger.info({ provider }, 'browser session reset');
 }
 const browserQueue = fastq.promise(async (task) => {
     inProgress.set(task.id, task);
@@ -343,14 +360,15 @@ function browserAddDirs() {
     ];
 }
 async function runBrowserTask(task) {
-    const session = loadBrowserSession();
+    const provider = getProvider();
+    const session = loadBrowserSession(provider.name);
     const isResume = !!session.sessionId;
     const prompt = buildBrowserPrompt(task, isResume);
     const elapsedLog = () => `${Math.round((Date.now() - task.startedAt * 1000) / 1000)}s`;
     let reply;
     let returnedSessionId;
     try {
-        const result = await getProvider().runTask({
+        const result = await provider.runTask({
             input: prompt,
             caller: 'browser-task',
             mode: 'auto',
@@ -375,7 +393,7 @@ async function runBrowserTask(task) {
     // sessionId; on resume it may return the same or a rotated one.
     if (returnedSessionId) {
         const now = Math.floor(Date.now() / 1000);
-        saveBrowserSession({
+        saveBrowserSession(provider.name, {
             sessionId: returnedSessionId,
             createdAt: session.createdAt || now,
             lastUsedAt: now,

package/dist/queue/worker.js

@@ -14,20 +14,21 @@ function isStaleSessionError(err) {
 async function callClaude(job) {
     const startedAt = Date.now();
     const wasFresh = !job.sessionId;
-    const { reply, sessionId, usage } = await getProvider().ask({
+    const provider = getProvider();
+    const { reply, sessionId, usage } = await provider.ask({
         input: job.input,
         sessionId: job.sessionId,
         allowedTools: job.allowedTools,
     });
     const durationMs = Date.now() - startedAt;
     if (!job.sessionId) {
-        setSession(job.jid, sessionId);
+        setSession(job.jid, provider.name, sessionId);
     }
     const totalContextTokens = usage.inputTokens +
         usage.cacheReadTokens +
         usage.cacheCreationTokens +
         usage.outputTokens;
-    setUsage(job.jid, {
+    setUsage(job.jid, provider.name, {
         ...usage,
         totalContextTokens,
         updatedAt: Math.floor(Date.now() / 1000),
@@ -133,7 +134,7 @@ export async function processJob(job) {
     catch (err) {
         if (job.sessionId && isStaleSessionError(err)) {
             logger.warn({ jid: job.jid, staleId: job.sessionId }, 'stale session detected, clearing and retrying with fresh bootstrap');
-            clearSession(job.jid);
+            clearSession(job.jid, getProvider().name);
             return callClaude({ ...job, sessionId: undefined, allowedTools: job.allowedTools });
         }
         throw err;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",