ccprofiles-core 0.5.1 → 0.7.0

package/README.md

@@ -0,0 +1,15 @@
+# ccprofiles-core
+
+Core library powering [`claude-account-sync`](https://www.npmjs.com/package/claude-account-sync) — the `clp` / `ccprofiles` CLI for managing multiple Claude Code and OpenAI Codex accounts.
+
+It provides the discovery, manifest, secrets, apply, and LAN-sync logic used by the CLI and its dashboard.
+
+- Adopts existing `.claude*` / `.codex*` homes into a declarative manifest
+- 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)
+- Drives encrypted, PIN-paired LAN replication between machines
+
+Repo: [github.com/tmfadhlul/claude-code-profile](https://github.com/tmfadhlul/claude-code-profile)
+
+Most users want the CLI, not this library — install `claude-account-sync` (`npm install -g claude-account-sync`) instead unless you're building on top of ccprofiles' internals.

package/dist/adopt.d.ts

@@ -1,7 +1,7 @@
 import { type LiveProfile } from './discovery.js';
 import type { Manifest } from './manifest.js';
 import { type Platform } from './platform.js';
-export declare function buildManifest(live: LiveProfile[], platform: Platform): Manifest;
+export declare function buildManifest(live: LiveProfile[], platform: Platform, sharedRoot?: string): Manifest;
 /**
  * Re-migrate secret refs after a snapshot/adopt rebuilds the manifest from live state.
  * Live settings.json holds resolved plaintext values, so a freshly built manifest would

package/dist/adopt.js

@@ -1,10 +1,22 @@
+import { join } from 'node:path';
 import { liveProfileName } from './discovery.js';
 import { toTemplate } from './platform.js';
-export function buildManifest(live, platform) {
+import { CLAUDE_SHARED_ENTRIES, CODEX_SHARED_ENTRIES } from './apply.js';
+export function buildManifest(live, platform, sharedRoot = join(platform.home, '.ccprofiles', 'shared')) {
+    // Same pool root planApply uses by default (join(home, '.ccprofiles', 'shared')), but
+    // callers with a custom CCPROFILES_HOME should pass join(ctx.manifestRoot, 'shared')
+    // instead. A profile-dir entry symlinked to <sharedRoot>/<entry> is a pooled session
+    // dir, not a plain link — recording it as a link would make the next apply think
+    // sharing is off and "unshare" it, copying the whole shared pool back into this one
+    // profile's dir.
     const mcpServers = {};
     for (const lp of live)
         for (const [name, def] of Object.entries(lp.mcpServers))
             mcpServers[name] ??= def;
+    const marketplaces = {};
+    for (const lp of live)
+        for (const [name, def] of Object.entries(lp.marketplaces ?? {}))
+            marketplaces[name] ??= def;
     // hub = profile whose dir is the most common link target prefix
     const linkVotes = new Map();
     for (const lp of live)
@@ -18,8 +30,14 @@ export function buildManifest(live, platform) {
     const hub = hubLive ? liveProfileName(hubLive) : null;
     const profiles = live.map(lp => {
         const name = liveProfileName(lp);
+        const sessionEntries = lp.agent === 'codex' ? CODEX_SHARED_ENTRIES : CLAUDE_SHARED_ENTRIES;
         const links = {};
+        let sharedSessions = false;
         for (const [entry, target] of Object.entries(lp.links)) {
+            if (sessionEntries.includes(entry) && target === join(sharedRoot, entry)) {
+                sharedSessions = true;
+                continue;
+            }
             const isHubLink = hubDirName && target.startsWith(live.find(o => o.dirName === hubDirName).dir);
             links[entry] = isHubLink ? 'hub' : toTemplate(target, platform);
         }
@@ -35,10 +53,13 @@ export function buildManifest(live, platform) {
             mcp: Object.keys(lp.mcpServers).sort(),
             settingsEnv: lp.settingsEnv,
             skipPermissions: false,
-            sharedSessions: false,
+            sharedSessions,
+            plugins: Object.entries(lp.enabledPlugins ?? {})
+                .filter(([k, v]) => v && marketplaces[k.slice(k.lastIndexOf('@') + 1)])
+                .map(([k]) => k).sort(),
         };
     });
-    return { version: 1, hub, profiles, mcpServers };
+    return { version: 1, hub, profiles, mcpServers, marketplaces };
 }
 /**
  * Re-migrate secret refs after a snapshot/adopt rebuilds the manifest from live state.

package/dist/apply.d.ts

@@ -1,6 +1,6 @@
 import type { Manifest, McpServerDef } from './manifest.js';
 import type { LiveProfile } from './discovery.js';
-import { type Platform } from './platform.js';
+import { type Platform, type OsKind } from './platform.js';
 export type ApplyAction = {
     kind: 'set-mcp-servers';
     agent: 'claude' | 'codex';
@@ -30,6 +30,9 @@ export type ApplyAction = {
     from: string;
     to: string;
 };
+export declare const CLAUDE_SHARED_ENTRIES: readonly ["projects", "todos", "shell-snapshots"];
+export declare const CODEX_SHARED_ENTRIES: readonly ["sessions"];
+export declare function isWithin(parent: string, child: string, osKind: OsKind): boolean;
 /** Resolve secret:// refs in every profile's settingsEnv. Throws on a missing secret. */
 export declare function resolveSettingsEnv(m: Manifest, getSecret: (name: string) => Promise<string | null>): Promise<Record<string, Record<string, string>>>;
 export declare function planApply(m: Manifest, live: LiveProfile[], p: Platform, resolvedSettingsEnv?: Record<string, Record<string, string>>, sharedRoot?: string): ApplyAction[];

package/dist/apply.js

@@ -1,6 +1,6 @@
 import { cp, lstat, mkdir, readFile, rm, symlink, unlink } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname, isAbsolute, relative } from 'node:path';
+import { join, dirname, posix as posixPath, win32 as win32Path } from 'node:path';
 import { renderPath } from './platform.js';
 import { renderRcBlock, upsertManagedBlock } from './rcblock.js';
 import { atomicWrite, backupFiles, backupTree } from './fsutil.js';
@@ -15,10 +15,17 @@ function sortKeys(o) {
     return Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
 }
 const SECRET_PREFIX = 'secret://';
-const CLAUDE_SHARED_ENTRIES = ['projects', 'todos', 'shell-snapshots'];
-function isWithin(parent, child) {
-    const rel = relative(parent, child);
-    return rel === '' || (rel !== '..' && !rel.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) && !isAbsolute(rel));
+// exported so adopt.ts (buildManifest) can recognize pooled session-dir symlinks with the
+// exact same entry list planApply uses to decide share/unshare — keeps both sides in lockstep.
+export const CLAUDE_SHARED_ENTRIES = ['projects', 'todos', 'shell-snapshots'];
+export const CODEX_SHARED_ENTRIES = ['sessions'];
+// exported for direct unit testing of the win32-vs-posix separator handling below
+export function isWithin(parent, child, osKind) {
+    // use the *target* platform's path implementation (osKind), not the host's — planApply is
+    // routinely called with an osKind that differs from process.platform (cross-platform plan/test)
+    const pathImpl = osKind === 'win32' ? win32Path : posixPath;
+    const rel = pathImpl.relative(parent, child);
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${pathImpl.sep}`) && !pathImpl.isAbsolute(rel));
 }
 /** Resolve secret:// refs in every profile's settingsEnv. Throws on a missing secret. */
 export async function resolveSettingsEnv(m, getSecret) {
@@ -48,8 +55,18 @@ export function planApply(m, live, p, resolvedSettingsEnv, sharedRoot = join(p.h
         const dir = renderPath(pr.dir, p);
         const lp = live.find(l => l.dir === dir) ?? null;
         const desired = {};
-        for (const name of pr.mcp)
-            desired[name] = m.mcpServers[name];
+        for (const name of pr.mcp) {
+            const def = m.mcpServers[name];
+            // codex has no per-server transport-type field (writeCodexMcpServers strips it on write);
+            // keep desired in the same shape as `current` here or the drift check never converges.
+            if (agent === 'codex') {
+                const { type: _claudeTransportType, ...codexDef } = def;
+                desired[name] = codexDef;
+            }
+            else {
+                desired[name] = def;
+            }
+        }
         if (!lp)
             actions.push({ kind: 'create-profile-dir', dir });
         const current = lp?.mcpServers ?? null;
@@ -64,13 +81,13 @@ export function planApply(m, live, p, resolvedSettingsEnv, sharedRoot = join(p.h
             const from = join(dir, physicalEntry);
             if (from === to)
                 continue;
-            if (isWithin(from, to) || isWithin(to, from))
+            if (isWithin(from, to, p.os) || isWithin(to, from, p.os))
                 throw new Error(`unsafe link topology: ${from} -> ${to} (source and target must not contain each other)`);
             if (lp?.links[entry] === to)
                 continue;
             actions.push({ kind: 'link', from, to });
         }
-        const sharedEntries = agent === 'codex' ? ['sessions'] : CLAUDE_SHARED_ENTRIES;
+        const sharedEntries = agent === 'codex' ? CODEX_SHARED_ENTRIES : CLAUDE_SHARED_ENTRIES;
         for (const entry of sharedEntries) {
             const from = join(dir, entry);
             const to = join(sharedRoot, entry);
@@ -120,14 +137,20 @@ export async function executeApply(actions, opts) {
         else if (a.kind === 'set-mcp-servers') {
             if (a.agent === 'codex') {
                 await mkdir(dirname(a.configPath), { recursive: true });
-                await writeCodexMcpServers(a.configPath, a.servers);
+                await writeCodexMcpServers(a.configPath, a.servers, { backupRoot: opts.backupRoot, stamp: opts.stamp });
                 continue;
             }
             let cfg = {};
             try {
                 cfg = JSON.parse(await readFile(a.configPath, 'utf8'));
             }
-            catch { /* new file */ }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    await backupFiles([a.configPath], opts.backupRoot, opts.stamp);
+                    throw new Error(`refusing to overwrite unreadable ${a.configPath} — back it up and fix it, then re-apply (${e.message})`);
+                }
+                // ENOENT: genuinely new file, cfg stays {}
+            }
             cfg.mcpServers = a.servers;
             await mkdir(dirname(a.configPath), { recursive: true });
             await atomicWrite(a.configPath, JSON.stringify(cfg, null, 2));
@@ -169,10 +192,17 @@ export async function executeApply(actions, opts) {
             try {
                 cfg = JSON.parse(await readFile(a.settingsPath, 'utf8'));
             }
-            catch { /* new file */ }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    await backupFiles([a.settingsPath], opts.backupRoot, opts.stamp);
+                    throw new Error(`refusing to overwrite unreadable ${a.settingsPath} — back it up and fix it, then re-apply (${e.message})`);
+                }
+                // ENOENT: genuinely new file, cfg stays {}
+            }
             cfg.env = a.env;
             await mkdir(dirname(a.settingsPath), { recursive: true });
-            await atomicWrite(a.settingsPath, JSON.stringify(cfg, null, 2));
+            // Resolved secret:// refs land here as plaintext env values — keep it 0600.
+            await atomicWrite(a.settingsPath, JSON.stringify(cfg, null, 2), { mode: 0o600 });
         }
         else if (a.kind === 'share-session-dir') {
             await mkdir(a.to, { recursive: true });

package/dist/assets.d.ts

@@ -2,5 +2,13 @@ import type { Manifest } from './manifest.js';
 import { type Platform } from './platform.js';
 /** Collect shareable assets as a relative-path → utf8-content map. */
 export declare function collectAssets(m: Manifest, p: Platform): Promise<Record<string, string>>;
-/** Write an asset map back to the live layout. */
-export declare function writeAssets(assets: Record<string, string>, m: Manifest, p: Platform): Promise<void>;
+export interface WriteAssetsBackup {
+    backupRoot: string;
+    stamp: string;
+}
+/**
+ * Write an asset map back to the live layout. Callers with an existing hub — i.e. `sync
+ * --from`/`bundle import` overwriting local skills/commands/guidance — should pass `backup`
+ * so any pre-existing target is preserved under `<backupRoot>/<stamp>/` before it's clobbered.
+ */
+export declare function writeAssets(assets: Record<string, string>, m: Manifest, p: Platform, backup?: WriteAssetsBackup): Promise<void>;

package/dist/assets.js

@@ -2,7 +2,7 @@ import { lstat, readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { renderPath } from './platform.js';
-import { atomicWrite } from './fsutil.js';
+import { atomicWrite, backupFiles } from './fsutil.js';
 import { physicalLinkEntry } from './links.js';
 const HUB_DIRS = ['skills', 'commands', 'plugins'];
 function safeParts(rel) {
@@ -64,8 +64,12 @@ export async function collectAssets(m, p) {
     }
     return assets;
 }
-/** Write an asset map back to the live layout. */
-export async function writeAssets(assets, m, p) {
+/**
+ * Write an asset map back to the live layout. Callers with an existing hub — i.e. `sync
+ * --from`/`bundle import` overwriting local skills/commands/guidance — should pass `backup`
+ * so any pre-existing target is preserved under `<backupRoot>/<stamp>/` before it's clobbered.
+ */
+export async function writeAssets(assets, m, p, backup) {
     const hub = m.profiles.find(x => x.name === m.hub);
     for (const [rel, content] of Object.entries(assets)) {
         const parts = safeParts(rel);
@@ -75,7 +79,10 @@ export async function writeAssets(assets, m, p) {
                 throw new Error(`unsafe asset path: ${JSON.stringify(rel)}`);
             const root = join(renderPath(hub.dir, p), physicalLinkEntry(hub.agent ?? 'claude', logicalEntry));
             await assertNoSymlinkParents(root, rest);
-            await atomicWrite(join(root, ...rest), content);
+            const target = join(root, ...rest);
+            if (backup && existsSync(target))
+                await backupFiles([target], backup.backupRoot, backup.stamp);
+            await atomicWrite(target, content);
         }
         else if (parts[0] === 'profiles') {
             const [, name, ...rest] = parts;
@@ -87,7 +94,10 @@ export async function writeAssets(assets, m, p) {
                 throw new Error(`unsafe profile asset path: ${JSON.stringify(rel)}`);
             const root = renderPath(pr.dir, p);
             await assertNoSymlinkParents(root, rest);
-            await atomicWrite(join(root, guidanceName), content);
+            const target = join(root, guidanceName);
+            if (backup && existsSync(target))
+                await backupFiles([target], backup.backupRoot, backup.stamp);
+            await atomicWrite(target, content);
         }
         else
             throw new Error(`unsafe asset path: ${JSON.stringify(rel)}`);

package/dist/codex.d.ts

@@ -7,4 +7,7 @@ import type { McpServerDef } from './manifest.js';
  */
 export declare function isProjectScopedMcpServer(def: McpServerDef): boolean;
 export declare function readCodexMcpServers(configPath: string): Promise<Record<string, McpServerDef>>;
-export declare function writeCodexMcpServers(configPath: string, servers: Record<string, McpServerDef>): Promise<void>;
+export declare function writeCodexMcpServers(configPath: string, servers: Record<string, McpServerDef>, backup?: {
+    backupRoot: string;
+    stamp: string;
+}): Promise<void>;

package/dist/codex.js

@@ -1,6 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { parse, stringify } from 'smol-toml';
-import { atomicWrite } from './fsutil.js';
+import { atomicWrite, backupFiles } from './fsutil.js';
 /**
  * Codex keeps every MCP server in one flat global `mcp_servers` table with no scope
  * marker, so per-project launchers (e.g. CCE's `cce serve --project-dir <path>`) sit
@@ -30,12 +30,19 @@ export async function readCodexMcpServers(configPath) {
         // user scope only — hide per-project launchers from the drift matrix, adopt, and sync
         .filter(([, def]) => !isProjectScopedMcpServer(def)));
 }
-export async function writeCodexMcpServers(configPath, servers) {
+export async function writeCodexMcpServers(configPath, servers, backup) {
     let config = {};
     try {
         config = parse(await readFile(configPath, 'utf8'));
     }
-    catch { /* new config */ }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            if (backup)
+                await backupFiles([configPath], backup.backupRoot, backup.stamp);
+            throw new Error(`refusing to overwrite unreadable ${configPath} — back it up and fix it, then re-apply (${e.message})`);
+        }
+        // ENOENT: genuinely new config, config stays {}
+    }
     // Preserve project-scoped launchers already in the file: clp hides them from management,
     // so a plain replace would silently delete them. Only user-scope servers are clp-managed.
     const existing = config.mcp_servers && typeof config.mcp_servers === 'object' && !Array.isArray(config.mcp_servers)

package/dist/devices.js

@@ -10,7 +10,7 @@ export async function loadDevices(root) {
     return JSON.parse(await readFile(f, 'utf8'));
 }
 export async function saveDevices(root, list) {
-    await atomicWrite(join(root, 'devices.json'), JSON.stringify(list, null, 2));
+    await atomicWrite(join(root, 'devices.json'), JSON.stringify(list, null, 2), { mode: 0o600 });
 }
 /** Keep secret-bearing files out of the manifest repo's auto-commits. */
 export async function ensureRootGitignore(root) {

package/dist/discovery.d.ts

@@ -9,6 +9,10 @@ export interface LiveProfile {
     mcpServers: Record<string, McpServerDef>;
     links: Record<string, string>;
     settingsEnv: Record<string, string>;
+    enabledPlugins: Record<string, boolean>;
+    marketplaces: Record<string, {
+        source: string;
+    }>;
 }
 export declare function discoverProfiles(home: string): Promise<LiveProfile[]>;
 export declare function liveProfileName(lp: Pick<LiveProfile, 'agent' | 'dirName'>): string;

package/dist/discovery.js

@@ -59,6 +59,7 @@ export async function discoverProfiles(home) {
             }
         }
         const settingsEnv = {};
+        const enabledPlugins = {};
         if (agent === 'claude')
             try {
                 const s = JSON.parse(await readFile(join(dir, 'settings.json'), 'utf8'));
@@ -66,8 +67,24 @@ export async function discoverProfiles(home) {
                     for (const [k, v] of Object.entries(s.env))
                         if (typeof v === 'string')
                             settingsEnv[k] = v;
+                if (s && typeof s.enabledPlugins === 'object' && s.enabledPlugins !== null)
+                    for (const [k, v] of Object.entries(s.enabledPlugins))
+                        if (typeof v === 'boolean')
+                            enabledPlugins[k] = v;
             }
             catch { /* no settings.json */ }
+        const marketplaces = {};
+        if (agent === 'claude')
+            try {
+                const km = JSON.parse(await readFile(join(dir, 'plugins', 'known_marketplaces.json'), 'utf8'));
+                if (km && typeof km === 'object')
+                    for (const [name, v] of Object.entries(km)) {
+                        const repo = v?.source?.repo;
+                        if (typeof repo === 'string')
+                            marketplaces[name] = { source: repo };
+                    }
+            }
+            catch { /* no plugins/known_marketplaces.json */ }
         out.push({
             agent,
             dirName: e.name,
@@ -78,6 +95,8 @@ export async function discoverProfiles(home) {
             mcpServers: agent === 'claude' ? cfg?.mcpServers ?? {} : await readCodexMcpServers(configPath),
             links,
             settingsEnv,
+            enabledPlugins,
+            marketplaces,
         });
     }
     return out.sort((a, b) => a.dirName.localeCompare(b.dirName));

package/dist/fsutil.d.ts

@@ -1,3 +1,5 @@
-export declare function atomicWrite(filePath: string, content: string): Promise<void>;
+export declare function atomicWrite(filePath: string, content: string, opts?: {
+    mode?: number;
+}): Promise<void>;
 export declare function backupFiles(files: string[], backupRoot: string, stamp: string): Promise<string>;
 export declare function backupTree(src: string, backupRoot: string, stamp: string): Promise<string | null>;

package/dist/fsutil.js

@@ -1,18 +1,26 @@
-import { copyFile, cp, mkdir, rename, writeFile } from 'node:fs/promises';
+import { chmod, copyFile, cp, mkdir, rename, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-export async function atomicWrite(filePath, content) {
-    await mkdir(dirname(filePath), { recursive: true });
+export async function atomicWrite(filePath, content, opts) {
+    // Secret-bearing writes (opts.mode set) also lock down the containing dir — it may be
+    // manifestRoot itself if this is the first file ever written there (e.g. `secrets set`
+    // before `adopt`/`manifest init` has created it).
+    await mkdir(dirname(filePath), opts?.mode ? { recursive: true, mode: 0o700 } : { recursive: true });
     const tmp = `${filePath}.ccp-tmp`;
-    await writeFile(tmp, content, 'utf8');
+    const mode = opts?.mode ?? 0o644;
+    await writeFile(tmp, content, { encoding: 'utf8', mode });
     await rename(tmp, filePath);
+    // rename preserves the temp file's mode, but chmod explicitly to sidestep umask surprises.
+    await chmod(filePath, mode);
 }
 function sanitize(absPath) {
     return absPath.replace(/:/g, '').replace(/[\\/]+/g, '__').replace(/^__/, '');
 }
 export async function backupFiles(files, backupRoot, stamp) {
     const dir = join(backupRoot, stamp);
-    await mkdir(dir, { recursive: true });
+    // Backups can contain copies of secret-bearing files (e.g. settings.json with resolved
+    // tokens) — keep the backup dir as locked down as the originals.
+    await mkdir(dir, { recursive: true, mode: 0o700 });
     for (const f of files) {
         if (!existsSync(f))
             continue;
@@ -25,7 +33,7 @@ export async function backupTree(src, backupRoot, stamp) {
         return null;
     const dir = join(backupRoot, stamp);
     const dest = join(dir, sanitize(src));
-    await mkdir(dir, { recursive: true });
+    await mkdir(dir, { recursive: true, mode: 0o700 });
     await cp(src, dest, { recursive: true });
     return dest;
 }

package/dist/handoff.d.ts

@@ -0,0 +1,21 @@
+import type { ProjectSessions, SessionTranscript } from './sessions.js';
+export declare function findLastSessionForCwd(scanned: ProjectSessions[], cwd: string, scope: string, agent: 'claude' | 'codex'): {
+    scope: string;
+    id: string;
+} | null;
+export declare function renderHandoffMarkdown(t: SessionTranscript): string;
+export declare function buildHandoffLaunch(opts: {
+    targetAgent: 'claude' | 'codex';
+    targetDir: string;
+    targetEnv: Record<string, string>;
+    skipPermissions: boolean;
+    transcriptPath: string;
+    srcName: string;
+    srcAgent: 'claude' | 'codex';
+    cwd: string;
+}): {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    cwd: string;
+};

package/dist/handoff.js

@@ -0,0 +1,38 @@
+export function findLastSessionForCwd(scanned, cwd, scope, agent) {
+    let newest = null;
+    for (const p of scanned) {
+        if (p.project !== cwd || p.scope !== scope || p.agent !== agent)
+            continue;
+        for (const s of p.sessions)
+            if (!newest || s.mtime > newest.mtime)
+                newest = { id: s.id, mtime: s.mtime };
+    }
+    return newest ? { scope, id: newest.id } : null;
+}
+export function renderHandoffMarkdown(t) {
+    const lines = [
+        '# Session handoff', '',
+        `- **From:** ${t.agent}`,
+        `- **Project:** ${t.project}`,
+        `- **Session:** ${t.id}`,
+        '', '---', '',
+    ];
+    for (const m of t.messages) {
+        const heading = m.role === 'tool'
+            ? `## Tool${m.label ? ` — ${m.label}` : ''}`
+            : `## ${m.role === 'user' ? 'User' : 'Assistant'}`;
+        lines.push(heading, '', m.text, '');
+    }
+    return lines.join('\n');
+}
+export function buildHandoffLaunch(opts) {
+    const homeVar = opts.targetAgent === 'codex' ? 'CODEX_HOME' : 'CLAUDE_CONFIG_DIR';
+    const command = opts.targetAgent === 'codex' ? 'codex' : 'claude';
+    const skipFlag = opts.skipPermissions
+        ? (opts.targetAgent === 'codex' ? '--dangerously-bypass-approvals-and-sandbox' : '--dangerously-skip-permissions')
+        : null;
+    const seedPrompt = `Continuing a session handed off from '${opts.srcName}' (${opts.srcAgent}). `
+        + `The full prior transcript is at ${opts.transcriptPath}. Read it, then pick up where it left off.`;
+    const args = skipFlag ? [skipFlag, seedPrompt] : [seedPrompt];
+    return { command, args, env: { [homeVar]: opts.targetDir, ...opts.targetEnv }, cwd: opts.cwd };
+}

package/dist/index.d.ts

@@ -15,3 +15,6 @@ export * from './syncserver.js';
 export * from './syncclient.js';
 export * from './bundle.js';
 export * from './sessions.js';
+export * from './handoff.js';
+export * from './plugins.js';
+export * from './provider.js';

package/dist/index.js

@@ -15,3 +15,6 @@ export * from './syncserver.js';
 export * from './syncclient.js';
 export * from './bundle.js';
 export * from './sessions.js';
+export * from './handoff.js';
+export * from './plugins.js';
+export * from './provider.js';

package/dist/manifest.d.ts

@@ -44,6 +44,7 @@ declare const ProfileSchema: z.ZodObject<{
     settingsEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     skipPermissions: z.ZodDefault<z.ZodBoolean>;
     sharedSessions: z.ZodDefault<z.ZodBoolean>;
+    plugins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
     env: Record<string, string>;
     name: string;
@@ -55,6 +56,7 @@ declare const ProfileSchema: z.ZodObject<{
     settingsEnv: Record<string, string>;
     skipPermissions: boolean;
     sharedSessions: boolean;
+    plugins: string[];
     agent?: "claude" | "codex" | undefined;
 }, {
     name: string;
@@ -68,6 +70,14 @@ declare const ProfileSchema: z.ZodObject<{
     settingsEnv?: Record<string, string> | undefined;
     skipPermissions?: boolean | undefined;
     sharedSessions?: boolean | undefined;
+    plugins?: string[] | undefined;
+}>;
+declare const MarketplaceSchema: z.ZodObject<{
+    source: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+}, {
+    source: string;
 }>;
 declare const ManifestSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -84,6 +94,7 @@ declare const ManifestSchema: z.ZodObject<{
         settingsEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
         skipPermissions: z.ZodDefault<z.ZodBoolean>;
         sharedSessions: z.ZodDefault<z.ZodBoolean>;
+        plugins: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         env: Record<string, string>;
         name: string;
@@ -95,6 +106,7 @@ declare const ManifestSchema: z.ZodObject<{
         settingsEnv: Record<string, string>;
         skipPermissions: boolean;
         sharedSessions: boolean;
+        plugins: string[];
         agent?: "claude" | "codex" | undefined;
     }, {
         name: string;
@@ -108,6 +120,7 @@ declare const ManifestSchema: z.ZodObject<{
         settingsEnv?: Record<string, string> | undefined;
         skipPermissions?: boolean | undefined;
         sharedSessions?: boolean | undefined;
+        plugins?: string[] | undefined;
     }>, "many">;
     mcpServers: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
         command: z.ZodOptional<z.ZodString>;
@@ -140,6 +153,13 @@ declare const ManifestSchema: z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
         url: z.ZodOptional<z.ZodString>;
     }, z.ZodTypeAny, "passthrough">>>;
+    marketplaces: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+    }, {
+        source: string;
+    }>>>;
 }, "strip", z.ZodTypeAny, {
     version: 1;
     hub: string | null;
@@ -154,6 +174,7 @@ declare const ManifestSchema: z.ZodObject<{
         settingsEnv: Record<string, string>;
         skipPermissions: boolean;
         sharedSessions: boolean;
+        plugins: string[];
         agent?: "claude" | "codex" | undefined;
     }[];
     mcpServers: Record<string, z.objectOutputType<{
@@ -163,6 +184,9 @@ declare const ManifestSchema: z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
         url: z.ZodOptional<z.ZodString>;
     }, z.ZodTypeAny, "passthrough">>;
+    marketplaces: Record<string, {
+        source: string;
+    }>;
 }, {
     version: 1;
     hub: string | null;
@@ -178,6 +202,7 @@ declare const ManifestSchema: z.ZodObject<{
         settingsEnv?: Record<string, string> | undefined;
         skipPermissions?: boolean | undefined;
         sharedSessions?: boolean | undefined;
+        plugins?: string[] | undefined;
     }[];
     mcpServers: Record<string, z.objectInputType<{
         command: z.ZodOptional<z.ZodString>;
@@ -186,10 +211,20 @@ declare const ManifestSchema: z.ZodObject<{
         type: z.ZodOptional<z.ZodString>;
         url: z.ZodOptional<z.ZodString>;
     }, z.ZodTypeAny, "passthrough">>;
+    marketplaces?: Record<string, {
+        source: string;
+    }> | undefined;
 }>;
 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>;
+/**
+ * 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
+ * (CLI + UI) use it to surface that skip as a visible problem instead of a stderr-only warning.
+ */
+export declare function manifestHasPlaintextSecret(yaml: string): boolean;
 /**
  * Reject manifests whose identifiers could break out of the shell launcher context.
  * Applies to every manifest — an untrusted bundle/peer manifest reaches this before