clementine-agent 1.0.46 → 1.0.48

package/dist/agent/assistant.js

@@ -1075,16 +1075,23 @@ You have a declarative registry of every integration you can configure. Use it:
 
 Companion tools: \`env_list\` (masked values + backend), \`env_unset\` (removes + clears Keychain entry).
 
-### When a tool call is refused
+### Self-update (when ${owner} asks you to update yourself)
 
-If any tool call fails with "not in my function schema" / "tool not allowed" / "unknown tool" while the tool appears in your SDK inventory:
+Call \`self_update\` — **never** manually \`cd ~/clementine && git pull\` or hunt for a source directory. There may be multiple clementine-related directories in home (stale \`~/clementine\`, the real \`~/clementine-dev\`, the data dir \`~/.clementine\`). \`self_update\` knows which source tree this daemon is actually running from — the others are stale or irrelevant and touching them will produce nothing useful while creating dangerous diverging state.
 
-1. Call \`allow_tool("<exact_tool_name>")\` — persists to your whitelist
-2. Retry the original call
+If you're unsure what's happening first, run \`where_is_source\` — it reports the absolute source path, current branch/commit, and whether there are uncommitted changes. \`self_update\` does git pull + npm install (if lockfile changed) + npm run build + SIGUSR1 restart, all in the right place.
 
-Takes effect on your next query. **Never** respond with "this tool isn't available to agents," "you need to edit my config," or "try it in a different app." If the tool name exists, you can add it.
+### Calling Claude Desktop connector tools (Drive, Gmail, etc.)
 
-\`list_allowed_tools\` / \`disallow_tool\` manage the list.
+**Do not inspect \`claude-integrations.json\` or any integration file to decide whether a tool is "loaded."** That file is a telemetry log, not a source of truth. Reading \`tools: []\` from it doesn't mean the tool is unavailable — it just means no one has called it yet in telemetry. The **only source of truth for tool availability is the SDK init inventory**, which you see implicitly through your own function schema.
+
+The right sequence when the user asks you to do something with a connector:
+
+1. **Just call the tool.** \`mcp__claude_ai_Google_Drive__search_files\`, \`mcp__claude_ai_Gmail__authenticate\`, etc. — attempt the call. If it works, great. If it returns an auth error, report the auth error. If it returns results, use them.
+2. **Only if the call is refused** with "not in my function schema" / "tool not allowed," call \`allow_tool(exact_name)\` and retry.
+3. **Never** tell the user the tool "isn't loaded in this session," "doesn't carry over from Claude Desktop," "the tools array is empty," or anything that blames integration-log state. Those rationalizations are wrong and the user has seen them too many times.
+
+\`list_allowed_tools\` / \`disallow_tool\` manage the whitelist. Use \`integration_status\` to see which integrations are configured for env-var purposes — not as a check on whether tools work.
 
 ## Context Window Management
 
@@ -1396,6 +1403,8 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             mcpTool('list_allowed_tools'),
             mcpTool('disallow_tool'),
             mcpTool('self_restart'),
+            mcpTool('self_update'),
+            mcpTool('where_is_source'),
             mcpTool('cron_list'),
             mcpTool('add_cron_job'),
             mcpTool('memory_report'),

package/dist/agent/mcp-bridge.js

@@ -443,6 +443,19 @@ export async function probeAvailableTools(force = false) {
         }
         const inv = { probedAt: new Date().toISOString(), tools };
         saveToolInventory(inv);
+        // Also sync claude-integrations.json so the agent-facing integration list
+        // stays consistent with what the SDK actually has available. Without this
+        // sync, the integrations file stays empty for freshly-connected services
+        // (e.g. Google_Drive tools: []) even though the inventory probe sees
+        // them — and the agent reads the integrations file, sees empty, and
+        // confabulates that the tools aren't loaded.
+        try {
+            const result = registerClaudeIntegrationsFromToolList(tools);
+            if (result.added.length + result.updated.length > 0) {
+                logger.info({ added: result.added, updated: result.updated }, 'Synced integrations from probed tool inventory');
+            }
+        }
+        catch { /* non-fatal */ }
         logger.info({ toolCount: tools.length }, 'Tool inventory probed');
         return inv;
     }

package/dist/tools/admin-tools.js

@@ -1381,8 +1381,128 @@ export function registerAdminTools(server) {
                 (args_description ? `Args: ${args_description}` : ''));
         }
     });
-    // ── Self-Restart ────────────────────────────────────────────────────────
-    server.tool('self_restart', 'Restart the Clementine daemon to pick up code changes. Sends SIGUSR1 to the running process, which triggers a graceful restart.', { _empty: z.string().optional().describe('(no parameters needed)') }, async () => {
+    // ── Self-Update / Self-Restart ─────────────────────────────────────────
+    /** Resolve the git-clone source dir this daemon is running from. */
+    function resolvePackageRoot() {
+        // This file is at clementine-dev/dist/tools/admin-tools.js at runtime.
+        // Climb two dirs to get the package root.
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        return path.resolve(here, '..', '..');
+    }
+    server.tool('where_is_source', 'Report the absolute path of the source tree this daemon is running from, whether it\'s a git clone, the current commit, and whether it has local uncommitted changes. Call this first before any self_update to confirm which checkout you\'re about to modify — avoids the "multiple clones in home dir" confusion where an agent updates the wrong one.', {}, async () => {
+        const root = resolvePackageRoot();
+        const gitDir = path.join(root, '.git');
+        const isGit = existsSync(gitDir);
+        const lines = [`Package root: ${root}`, `Git repo: ${isGit ? 'yes' : 'no'}`];
+        if (isGit) {
+            try {
+                const commit = execSync('git rev-parse --short HEAD', { cwd: root, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+                const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: root, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+                const status = execSync('git status --porcelain', { cwd: root, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+                lines.push(`Branch: ${branch} @ ${commit}`);
+                lines.push(`Uncommitted changes: ${status ? 'yes' : 'no'}`);
+                if (status)
+                    lines.push(`\n${status}`);
+            }
+            catch { /* best-effort */ }
+        }
+        lines.push('', 'ONLY modify files under this path when updating source. Other ~/clementine* directories may be stale checkouts — ignore them.');
+        return textResult(lines.join('\n'));
+    });
+    server.tool('self_update', 'Update Clementine to the latest main-branch code and restart. Runs git pull + npm install (if lockfile changed) + npm run build in the running daemon\'s source dir, then signals SIGUSR1 to restart. Owner-DM only. Use this instead of manually invoking git/npm — it operates on the correct source dir and handles the restart cleanly. Returns immediately; the daemon will be unreachable for ~15s during rebuild+restart.', {
+        branch: z.string().optional().describe('Branch to pull (default "main")'),
+    }, async ({ branch }) => {
+        const gate = requireOwnerDm();
+        if (!gate.ok)
+            return textResult(gate.message);
+        const root = resolvePackageRoot();
+        if (!existsSync(path.join(root, '.git'))) {
+            return textResult(`Refused: ${root} is not a git clone. This daemon was likely installed via npm — updates should go through \`npm install -g clementine-agent@latest\`, not self_update.`);
+        }
+        const targetBranch = branch ?? 'main';
+        const out = [];
+        const runQuiet = (cmd, args, timeout = 120000) => {
+            try {
+                const res = execSync(`${cmd} ${args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ')}`, {
+                    cwd: root, encoding: 'utf-8', timeout,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                });
+                return { ok: true, output: res };
+            }
+            catch (e) {
+                return { ok: false, output: (e?.stdout ?? '') + '\n' + (e?.stderr ?? '') + '\n' + String(e).slice(0, 200) };
+            }
+        };
+        // 1. Stash local changes so git pull is clean
+        const statusProbe = runQuiet('git', ['status', '--porcelain']);
+        const hadLocal = statusProbe.ok && statusProbe.output.trim().length > 0;
+        let stashed = false;
+        if (hadLocal) {
+            const stashRes = runQuiet('git', ['stash', 'push', '-u', '-m', `self_update ${new Date().toISOString()}`]);
+            if (stashRes.ok) {
+                stashed = true;
+                out.push('Stashed local changes (restore with `git stash pop` in the source dir if needed).');
+            }
+            else {
+                return textResult(`Refused: couldn't stash local changes in ${root}. ${stashRes.output.slice(0, 200)}`);
+            }
+        }
+        // 2. Checkout target branch if not already there
+        const branchProbe = runQuiet('git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+        if (branchProbe.ok && branchProbe.output.trim() !== targetBranch) {
+            const coRes = runQuiet('git', ['checkout', targetBranch]);
+            if (!coRes.ok)
+                return textResult(`git checkout ${targetBranch} failed: ${coRes.output.slice(0, 300)}`);
+        }
+        // 3. Record pre-pull hashes so we know if package-lock changed
+        const preLock = existsSync(path.join(root, 'package-lock.json')) ? readFileSync(path.join(root, 'package-lock.json'), 'utf-8').length : 0;
+        const preCommit = runQuiet('git', ['rev-parse', 'HEAD']).output.trim();
+        // 4. Pull
+        const pullRes = runQuiet('git', ['pull', '--ff-only', 'origin', targetBranch], 60000);
+        if (!pullRes.ok)
+            return textResult(`git pull failed: ${pullRes.output.slice(0, 300)}\n\n${stashed ? 'Local changes are preserved in git stash; inspect with `git stash list`.' : ''}`);
+        const postCommit = runQuiet('git', ['rev-parse', 'HEAD']).output.trim();
+        if (preCommit === postCommit) {
+            out.push(`Already up to date at ${preCommit.slice(0, 7)}.`);
+            return textResult(out.join('\n'));
+        }
+        out.push(`Pulled: ${preCommit.slice(0, 7)} → ${postCommit.slice(0, 7)}`);
+        // 5. npm install only if package-lock changed
+        const postLock = existsSync(path.join(root, 'package-lock.json')) ? readFileSync(path.join(root, 'package-lock.json'), 'utf-8').length : 0;
+        if (postLock !== preLock) {
+            out.push('package-lock.json changed — running npm install...');
+            const installRes = runQuiet('npm', ['install'], 180000);
+            if (!installRes.ok)
+                return textResult(`${out.join('\n')}\n\nnpm install failed: ${installRes.output.slice(0, 300)}`);
+            out.push('  ok');
+        }
+        // 6. Build
+        out.push('Building...');
+        const buildRes = runQuiet('npm', ['run', 'build'], 300000);
+        if (!buildRes.ok)
+            return textResult(`${out.join('\n')}\n\nBuild failed: ${buildRes.output.slice(0, 300)}`);
+        out.push('  ok');
+        // 7. Trigger graceful self-restart
+        const pidFile = path.join(BASE_DIR, `.${(env['ASSISTANT_NAME'] ?? 'clementine').toLowerCase()}.pid`);
+        if (existsSync(pidFile)) {
+            const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+            if (!isNaN(pid)) {
+                try {
+                    process.kill(pid, 0);
+                    process.kill(pid, 'SIGUSR1');
+                    out.push(`Sent SIGUSR1 to PID ${pid}. I'll be back in ~15s on the new build.`);
+                }
+                catch {
+                    out.push('Daemon PID not running — no restart signal sent. New build is on disk; launch manually.');
+                }
+            }
+        }
+        else {
+            out.push('No PID file found. Build succeeded but restart not triggered — run `clementine launch` manually.');
+        }
+        return textResult(out.join('\n'));
+    });
+    server.tool('self_restart', 'Restart the Clementine daemon to pick up code changes. Sends SIGUSR1 to the running process, which triggers a graceful restart. Use self_update instead if you also need to pull/build first.', { _empty: z.string().optional().describe('(no parameters needed)') }, async () => {
         const pidFile = path.join(BASE_DIR, `.${(env['ASSISTANT_NAME'] ?? 'clementine').toLowerCase()}.pid`);
         if (!existsSync(pidFile)) {
             return textResult('No PID file found — daemon may not be running.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.0.46",
+  "version": "1.0.48",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",