ccprofiles-core 0.10.2 → 0.11.0

package/README.md

@@ -8,6 +8,9 @@ It provides the discovery, manifest, secrets, apply, and LAN-sync logic used by
 - Applies profile config (launchers, env, links, MCP servers) with surgical, backed-up edits
 - Reads/writes secrets across macOS Keychain, libsecret, and encrypted-file backends
 - Computes MCP server drift across profiles and both agents (Claude + Codex)
+- Builds headless launches that run one profile's agent as a subagent of another session, stripping the caller's provider env so a gateway profile cannot re-point a Claude delegate (`delegate.ts`)
+- Checks which files a delegate touched against a declared path lane, counting created, edited, deleted, reverted, and committed work (`scope.ts`)
+- Mirrors one `statusLine` block into every claude profile, since Claude Code reads it per `CLAUDE_CONFIG_DIR`
 - Drives encrypted, PIN-paired LAN replication between machines
 
 Repo: [github.com/tmfadhlul/claude-code-profile](https://github.com/tmfadhlul/claude-code-profile)

package/dist/apply.js

@@ -116,7 +116,9 @@ export function planApply(m, live, p, resolvedSettingsEnv, sharedRoot = join(p.h
                 actions.push({ kind: 'unshare-session-dir', from, to });
         }
         const senv = pr.settingsEnv ?? {}; // literals in older tests may omit the field
-        if (agent === 'claude' && Object.keys(senv).length > 0) {
+        // No length guard: an empty settingsEnv is a declaration ("no env"), so it must still clear
+        // whatever is live — otherwise `provider anthropic --login` leaves the old token in place.
+        if (agent === 'claude') {
             let desired = resolvedSettingsEnv?.[pr.name];
             if (!desired) {
                 if (Object.values(senv).some(v => v.startsWith(SECRET_PREFIX)))
@@ -124,7 +126,10 @@ export function planApply(m, live, p, resolvedSettingsEnv, sharedRoot = join(p.h
                 desired = senv;
             }
             const currentEnv = lp?.settingsEnv ?? null;
-            if (!currentEnv || JSON.stringify(sortKeys(currentEnv)) !== JSON.stringify(sortKeys(desired))) {
+            const drift = currentEnv
+                ? JSON.stringify(sortKeys(currentEnv)) !== JSON.stringify(sortKeys(desired))
+                : Object.keys(desired).length > 0; // no live dir yet: don't create settings.json just to write {}
+            if (drift) {
                 actions.push({ kind: 'set-settings-env', settingsPath: join(dir, 'settings.json'), env: desired });
             }
         }

package/dist/manifest.d.ts

@@ -226,6 +226,7 @@ export type McpServerDef = z.infer<typeof McpServerSchema>;
 export type ProfileDecl = z.infer<typeof ProfileSchema>;
 export type Manifest = z.infer<typeof ManifestSchema>;
 export type MarketplaceDef = z.infer<typeof MarketplaceSchema>;
+export declare const SAFE_NAME: RegExp;
 /**
  * True if `yaml` (raw manifest.yaml text, or any string) contains a plaintext provider
  * token. saveManifest() uses this to decide whether to skip the git commit; doctor checks

package/dist/manifest.js

@@ -45,7 +45,9 @@ const ManifestSchema = z.object({
 // identifiers that get interpolated into shell launcher code must be injection-safe
 // leading '-' is forbidden (but internal '-' still allowed) so a value can never be parsed as a
 // CLI flag when passed as a positional argv entry (e.g. `claude plugin install <id>`)
-const SAFE_NAME = /^[A-Za-z0-9_][A-Za-z0-9_-]*$/; // profile names, launcher names, secret refs
+// exported: SecretsStore.set() rejects names this forbids, so a secret can never be stored under
+// a name no manifest could ever reference (the failure used to surface only at attach time)
+export const SAFE_NAME = /^[A-Za-z0-9_][A-Za-z0-9_-]*$/; // profile names, launcher names, secret refs
 const SAFE_ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/; // POSIX/PowerShell env var names
 const SAFE_LINK_ENTRY = /^[A-Za-z0-9._-]+$/; // one profile-dir child; never a path
 const SAFE_SOURCE = /^[A-Za-z0-9._@:/][A-Za-z0-9._/@:-]*$/; // marketplace source (interpolated into `claude plugin` shell-out); no leading '-'
@@ -181,7 +183,9 @@ export async function saveManifest(root, m) {
 /** True for the two git outcomes saveManifest treats as expected/benign, not a real failure. */
 function isBenignGitError(e) {
     const text = gitErrorMessage(e);
-    return /nothing to commit/i.test(text) || /not a git repository/i.test(text);
+    // "no changes added to commit" is git's wording when the only dirty paths are ones `add -A`
+    // cannot stage (nested repos) — still nothing for us to commit.
+    return /nothing to commit/i.test(text) || /no changes added to commit/i.test(text) || /not a git repository/i.test(text);
 }
 function gitErrorMessage(e) {
     const err = e;

package/dist/plugins.d.ts

@@ -1,5 +1,8 @@
 export interface PluginRunner {
     marketplaceAdd(configDir: string, source: string): Promise<void>;
+    /** `claude plugin marketplace update` — refetch the marketplace so "latest" is actually latest.
+     *  Without this, `update` is a silent no-op in any profile whose marketplace clone is stale. */
+    marketplaceUpdate(configDir: string, name: string): Promise<void>;
     install(configDir: string, id: string): Promise<void>;
     uninstall(configDir: string, id: string): Promise<void>;
     /** `claude plugin update` — moves a plugin to the marketplace's latest. There is deliberately no
@@ -76,3 +79,23 @@ export declare function claudeMemCacheDirs(configDir: string): Promise<string[]>
 export declare function pruneStaleVersionDirs(cacheDir: string): Promise<string[]>;
 /** If a profile's plugins/ is a legacy symlink into the old shared pool, restore it to a real dir. */
 export declare function restoreLegacyPluginSymlink(pluginsDir: string): Promise<boolean>;
+/**
+ * Repair installed_plugins.json entries whose installPath no longer exists on disk.
+ *
+ * This is the other half of pruneStaleVersionDirs. Pruning removes superseded cache dirs but leaves
+ * the bookkeeping untouched, and installed_plugins.json holds one entry PER SCOPE — a `user` entry
+ * plus a `project` entry for every directory Claude was ever launched from. `claude plugin update`
+ * only moves the user-scope pin, so the project-scope entries stay on an old version, and the next
+ * prune deletes the dir underneath them. Claude Code then refuses to load their hooks outright:
+ * "Plugin directory does not exist: .../claude-mem/13.16.1 — run /plugin to reinstall", on every
+ * Stop hook, forever. Six of eight profiles were in that state on 2026-08-30.
+ *
+ * Re-point rather than drop where a sibling version dir survived: the surviving dir is the one
+ * prune kept, i.e. the latest, which is exactly where `claude plugin update` would have moved the
+ * entry anyway — so the repair converges scopes onto one version instead of disabling the plugin.
+ * Only numeric version dirs qualify; a versionless plugin's sha/"unknown" siblings are unrelated
+ * builds, so those entries are dropped and left for `plugins apply` to reinstall.
+ */
+export declare function repairInstalledPlugins(configDir: string, opts?: {
+    dryRun?: boolean;
+}): Promise<string[]>;

package/dist/plugins.js

@@ -1,6 +1,7 @@
-import { cp, lstat, mkdir, readdir, readlink, rm, unlink } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { cp, lstat, mkdir, readdir, readFile, readlink, rm, unlink } from 'node:fs/promises';
+import { existsSync, readdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { atomicWrite } from './fsutil.js';
 export function marketplaceOf(id) {
     const at = id.lastIndexOf('@');
     return at > 0 ? id.slice(at + 1) : null;
@@ -67,6 +68,18 @@ export async function reconcileProfilePlugins(opts) {
         await opts.runner.install(opts.configDir, id);
         log.push(`install ${id}`);
     }
+    // `claude plugin update` moves to the marketplace clone's latest, and that clone is per-profile
+    // and only refreshed on demand. A profile whose clone is months old therefore "updates" to the
+    // version it already has, and cross-profile drift never converges — refetch first.
+    const refreshed = new Set();
+    for (const id of update) {
+        const mkt = marketplaceOf(id);
+        if (mkt && !refreshed.has(mkt)) {
+            await opts.runner.marketplaceUpdate(opts.configDir, mkt);
+            refreshed.add(mkt);
+            log.push(`marketplace update ${mkt}`);
+        }
+    }
     for (const id of update) {
         await opts.runner.update(opts.configDir, id);
         log.push(`update ${id}`);
@@ -166,3 +179,75 @@ export async function restoreLegacyPluginSymlink(pluginsDir) {
     await cp(target, pluginsDir, { recursive: true, force: false, errorOnExist: false });
     return true;
 }
+/** Highest-semver cache dir that still exists beside a missing one, or null if none survived. */
+function survivingVersionDir(missingPath) {
+    const parent = dirname(missingPath);
+    let names;
+    try {
+        names = readdirSync(parent);
+    }
+    catch {
+        return null;
+    }
+    const versions = names.filter(n => /^\d/.test(n) && existsSync(join(parent, n))).sort(compareVersionDir);
+    return versions.length ? join(parent, versions[versions.length - 1]) : null;
+}
+/**
+ * Repair installed_plugins.json entries whose installPath no longer exists on disk.
+ *
+ * This is the other half of pruneStaleVersionDirs. Pruning removes superseded cache dirs but leaves
+ * the bookkeeping untouched, and installed_plugins.json holds one entry PER SCOPE — a `user` entry
+ * plus a `project` entry for every directory Claude was ever launched from. `claude plugin update`
+ * only moves the user-scope pin, so the project-scope entries stay on an old version, and the next
+ * prune deletes the dir underneath them. Claude Code then refuses to load their hooks outright:
+ * "Plugin directory does not exist: .../claude-mem/13.16.1 — run /plugin to reinstall", on every
+ * Stop hook, forever. Six of eight profiles were in that state on 2026-08-30.
+ *
+ * Re-point rather than drop where a sibling version dir survived: the surviving dir is the one
+ * prune kept, i.e. the latest, which is exactly where `claude plugin update` would have moved the
+ * entry anyway — so the repair converges scopes onto one version instead of disabling the plugin.
+ * Only numeric version dirs qualify; a versionless plugin's sha/"unknown" siblings are unrelated
+ * builds, so those entries are dropped and left for `plugins apply` to reinstall.
+ */
+export async function repairInstalledPlugins(configDir, opts = {}) {
+    const file = join(configDir, 'plugins', 'installed_plugins.json');
+    let doc;
+    // A corrupt file must not be rewritten from a half-parse — bail and leave it for a human.
+    try {
+        doc = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    if (!doc?.plugins || typeof doc.plugins !== 'object')
+        return [];
+    const log = [];
+    for (const [id, entries] of Object.entries(doc.plugins)) {
+        if (!Array.isArray(entries))
+            continue;
+        const kept = [];
+        for (const e of entries) {
+            const path = e?.installPath;
+            if (typeof path !== 'string' || existsSync(path)) {
+                kept.push(e);
+                continue;
+            }
+            const scope = e.scope ?? '?';
+            const survivor = survivingVersionDir(path);
+            if (survivor) {
+                kept.push({ ...e, installPath: survivor, version: basename(survivor) });
+                log.push(`${id} (${scope}): ${e.version} → ${basename(survivor)} — cache dir was pruned`);
+            }
+            else {
+                log.push(`${id} (${scope}): dropped — ${path} is gone and no version survived`);
+            }
+        }
+        if (kept.length)
+            doc.plugins[id] = kept;
+        else
+            delete doc.plugins[id];
+    }
+    if (log.length && !opts.dryRun)
+        await atomicWrite(file, JSON.stringify(doc, null, 2) + '\n');
+    return log;
+}

package/dist/secrets.js

@@ -4,6 +4,7 @@ import { existsSync } from 'node:fs';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { atomicWrite } from './fsutil.js';
+import { SAFE_NAME } from './manifest.js';
 export class FileBackend {
     filePath;
     passphrase;
@@ -176,6 +177,8 @@ export class SecretsStore {
     get backendName() { return this.backend.name; }
     async get(key) { return this.backend.get(key); }
     async set(key, value) {
+        if (!SAFE_NAME.test(key))
+            throw new Error(`unsafe secret name: ${JSON.stringify(key)} (allowed: letters, digits, - _; must not start with -)`);
         await this.backend.set(key, value);
         await this.writeIndex([...(await this.readIndex()), key]);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccprofiles-core",
-  "version": "0.10.2",
+  "version": "0.11.0",
   "description": "Core library for ccprofiles — discovery, manifest, secrets, apply, and LAN sync for Claude Code multi-account setups",
   "type": "module",
   "main": "./dist/index.js",