ccprofiles-core 0.4.0 → 0.5.0

package/dist/adopt.d.ts

@@ -1,4 +1,4 @@
-import type { LiveProfile } from './discovery.js';
+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;

package/dist/adopt.js

@@ -1,7 +1,5 @@
+import { liveProfileName } from './discovery.js';
 import { toTemplate } from './platform.js';
-function profileName(dirName) {
-    return dirName === '.claude' ? 'default' : dirName.slice('.claude-'.length);
-}
 export function buildManifest(live, platform) {
     const mcpServers = {};
     for (const lp of live)
@@ -16,24 +14,28 @@ export function buildManifest(live, platform) {
                 linkVotes.set(owner.dirName, (linkVotes.get(owner.dirName) ?? 0) + 1);
         }
     const hubDirName = [...linkVotes.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
-    const hub = hubDirName ? profileName(hubDirName) : null;
+    const hubLive = hubDirName ? live.find(lp => lp.dirName === hubDirName) : null;
+    const hub = hubLive ? liveProfileName(hubLive) : null;
     const profiles = live.map(lp => {
-        const name = profileName(lp.dirName);
+        const name = liveProfileName(lp);
         const links = {};
         for (const [entry, target] of Object.entries(lp.links)) {
             const isHubLink = hubDirName && target.startsWith(live.find(o => o.dirName === hubDirName).dir);
             links[entry] = isHubLink ? 'hub' : toTemplate(target, platform);
         }
         return {
+            agent: lp.agent,
             name,
             dir: toTemplate(lp.dir, platform),
-            launcher: name === 'default' ? null : `cl-${name}`,
-            auth: lp.account ? 'oauth' : 'env',
+            launcher: lp.dirName === '.claude' || lp.dirName === '.codex' ? null
+                : lp.agent === 'codex' ? `cx-${lp.dirName.slice('.codex-'.length)}` : `cl-${name}`,
+            auth: lp.account || lp.authenticated ? 'oauth' : 'env',
             env: {},
             links,
             mcp: Object.keys(lp.mcpServers).sort(),
             settingsEnv: lp.settingsEnv,
             skipPermissions: false,
+            sharedSessions: false,
         };
     });
     return { version: 1, hub, profiles, mcpServers };

package/dist/apply.d.ts

@@ -3,6 +3,7 @@ import type { LiveProfile } from './discovery.js';
 import { type Platform } from './platform.js';
 export type ApplyAction = {
     kind: 'set-mcp-servers';
+    agent: 'claude' | 'codex';
     configPath: string;
     servers: Record<string, McpServerDef>;
 } | {
@@ -20,10 +21,18 @@ export type ApplyAction = {
     kind: 'set-settings-env';
     settingsPath: string;
     env: Record<string, string>;
+} | {
+    kind: 'share-session-dir';
+    from: string;
+    to: string;
+} | {
+    kind: 'unshare-session-dir';
+    from: string;
+    to: string;
 };
 /** 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>>): ApplyAction[];
+export declare function planApply(m: Manifest, live: LiveProfile[], p: Platform, resolvedSettingsEnv?: Record<string, Record<string, string>>, sharedRoot?: string): ApplyAction[];
 export declare function executeApply(actions: ApplyAction[], opts: {
     backupRoot: string;
     stamp: string;

package/dist/apply.js

@@ -1,16 +1,25 @@
-import { lstat, mkdir, readFile, symlink, unlink } from 'node:fs/promises';
+import { cp, lstat, mkdir, readFile, rm, symlink, unlink } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { join, dirname, isAbsolute, relative } from 'node:path';
 import { renderPath } from './platform.js';
 import { renderRcBlock, upsertManagedBlock } from './rcblock.js';
-import { atomicWrite, backupFiles } from './fsutil.js';
-function configPathFor(dir, home) {
+import { atomicWrite, backupFiles, backupTree } from './fsutil.js';
+import { writeCodexMcpServers } from './codex.js';
+import { physicalLinkEntry } from './links.js';
+function configPathFor(dir, home, agent) {
+    if (agent === 'codex')
+        return join(dir, 'config.toml');
     return dir === join(home, '.claude') ? join(home, '.claude.json') : join(dir, '.claude.json');
 }
 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));
+}
 /** Resolve secret:// refs in every profile's settingsEnv. Throws on a missing secret. */
 export async function resolveSettingsEnv(m, getSecret) {
     const out = {};
@@ -31,10 +40,11 @@ export async function resolveSettingsEnv(m, getSecret) {
     }
     return out;
 }
-export function planApply(m, live, p, resolvedSettingsEnv) {
+export function planApply(m, live, p, resolvedSettingsEnv, sharedRoot = join(p.home, '.ccprofiles', 'shared')) {
     const actions = [];
     const hubProfile = m.profiles.find(x => x.name === m.hub) ?? null;
     for (const pr of m.profiles) {
+        const agent = pr.agent ?? 'claude';
         const dir = renderPath(pr.dir, p);
         const lp = live.find(l => l.dir === dir) ?? null;
         const desired = {};
@@ -44,19 +54,34 @@ export function planApply(m, live, p, resolvedSettingsEnv) {
             actions.push({ kind: 'create-profile-dir', dir });
         const current = lp?.mcpServers ?? null;
         if (!current || JSON.stringify(sortKeys(current)) !== JSON.stringify(sortKeys(desired))) {
-            actions.push({ kind: 'set-mcp-servers', configPath: configPathFor(dir, p.home), servers: desired });
+            actions.push({ kind: 'set-mcp-servers', agent, configPath: configPathFor(dir, p.home, agent), servers: desired });
         }
         for (const [entry, target] of Object.entries(pr.links)) {
+            const physicalEntry = physicalLinkEntry(agent, entry);
             const to = target === 'hub' && hubProfile
-                ? join(renderPath(hubProfile.dir, p), entry)
+                ? join(renderPath(hubProfile.dir, p), physicalLinkEntry(hubProfile.agent ?? 'claude', entry))
                 : renderPath(target, p);
-            const from = join(dir, entry);
+            const from = join(dir, physicalEntry);
+            if (from === to)
+                continue;
+            if (isWithin(from, to) || isWithin(to, from))
+                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;
+        for (const entry of sharedEntries) {
+            const from = join(dir, entry);
+            const to = join(sharedRoot, entry);
+            const linkedToPool = lp?.links[entry] === to;
+            if (pr.sharedSessions && !linkedToPool)
+                actions.push({ kind: 'share-session-dir', from, to });
+            else if (!pr.sharedSessions && linkedToPool)
+                actions.push({ kind: 'unshare-session-dir', from, to });
+        }
         const senv = pr.settingsEnv ?? {}; // literals in older tests may omit the field
-        if (Object.keys(senv).length > 0) {
+        if (agent === 'claude' && Object.keys(senv).length > 0) {
             let desired = resolvedSettingsEnv?.[pr.name];
             if (!desired) {
                 if (Object.values(senv).some(v => v.startsWith(SECRET_PREFIX)))
@@ -87,12 +112,17 @@ export async function executeApply(actions, opts) {
         : a.kind === 'rc-block' ? [a.rcFile]
             : a.kind === 'set-settings-env' ? [a.settingsPath]
                 : []);
-    const backupDir = touched.length ? await backupFiles(touched, opts.backupRoot, opts.stamp) : null;
+    let backupDir = touched.length ? await backupFiles(touched, opts.backupRoot, opts.stamp) : null;
     for (const a of actions) {
         if (a.kind === 'create-profile-dir') {
             await mkdir(a.dir, { recursive: true });
         }
         else if (a.kind === 'set-mcp-servers') {
+            if (a.agent === 'codex') {
+                await mkdir(dirname(a.configPath), { recursive: true });
+                await writeCodexMcpServers(a.configPath, a.servers);
+                continue;
+            }
             let cfg = {};
             try {
                 cfg = JSON.parse(await readFile(a.configPath, 'utf8'));
@@ -103,18 +133,26 @@ export async function executeApply(actions, opts) {
             await atomicWrite(a.configPath, JSON.stringify(cfg, null, 2));
         }
         else if (a.kind === 'link') {
+            let st = null;
             try {
-                const st = await lstat(a.from);
-                if (!st.isSymbolicLink())
-                    throw new Error(`refusing to replace non-symlink: ${a.from}`);
-                await unlink(a.from);
+                st = await lstat(a.from);
             }
-            catch (e) {
-                if (e.code !== 'ENOENT') {
-                    if (typeof e.message === 'string' && e.message.startsWith('refusing'))
-                        throw e;
-                }
+            catch { /* absent */ }
+            if (st && !st.isSymbolicLink()) {
+                // Preserve profile-local assets, then merge unique entries into shared target.
+                // Existing target files win name conflicts; complete source remains in backup.
+                const treeBackup = await backupTree(a.from, opts.backupRoot, opts.stamp);
+                if (treeBackup)
+                    backupDir ??= dirname(treeBackup);
+                await mkdir(a.to, { recursive: true });
+                await cp(a.from, a.to, { recursive: true, force: false, errorOnExist: false });
+                await rm(a.from, { recursive: true, force: true });
+            }
+            else if (st) {
+                await unlink(a.from);
             }
+            await mkdir(a.to, { recursive: true });
+            await mkdir(dirname(a.from), { recursive: true });
             await symlink(a.to, a.from, process.platform === 'win32' ? 'junction' : 'dir');
         }
         else if (a.kind === 'rc-block') {
@@ -136,6 +174,37 @@ export async function executeApply(actions, opts) {
             await mkdir(dirname(a.settingsPath), { recursive: true });
             await atomicWrite(a.settingsPath, JSON.stringify(cfg, null, 2));
         }
+        else if (a.kind === 'share-session-dir') {
+            await mkdir(a.to, { recursive: true });
+            let st = null;
+            try {
+                st = await lstat(a.from);
+            }
+            catch { /* absent */ }
+            if (st && !st.isSymbolicLink()) {
+                const treeBackup = await backupTree(a.from, opts.backupRoot, opts.stamp);
+                if (treeBackup)
+                    backupDir ??= dirname(treeBackup);
+                await cp(a.from, a.to, { recursive: true, force: false, errorOnExist: false });
+                await rm(a.from, { recursive: true, force: true });
+            }
+            else if (st && st.isSymbolicLink()) {
+                await unlink(a.from);
+            }
+            await mkdir(dirname(a.from), { recursive: true });
+            await symlink(a.to, a.from, process.platform === 'win32' ? 'junction' : 'dir');
+        }
+        else if (a.kind === 'unshare-session-dir') {
+            try {
+                const st = await lstat(a.from);
+                if (st.isSymbolicLink())
+                    await unlink(a.from);
+            }
+            catch { /* absent */ }
+            await mkdir(a.from, { recursive: true });
+            if (existsSync(a.to))
+                await cp(a.to, a.from, { recursive: true, force: false, errorOnExist: false });
+        }
     }
     return { backupDir, performed };
 }
@@ -146,5 +215,7 @@ function describe(a) {
         case 'link': return `link ${a.from} -> ${a.to}`;
         case 'rc-block': return `update managed block in ${a.rcFile}`;
         case 'set-settings-env': return `set settings env (${Object.keys(a.env).length}) in ${a.settingsPath}`;
+        case 'share-session-dir': return `share ${a.from} -> ${a.to}`;
+        case 'unshare-session-dir': return `unshare ${a.from} (seed from ${a.to})`;
     }
 }

package/dist/assets.js

@@ -1,9 +1,33 @@
-import { readdir, readFile } from 'node:fs/promises';
+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';
-const HUB_DIRS = ['skills', 'commands'];
+import { physicalLinkEntry } from './links.js';
+const HUB_DIRS = ['skills', 'commands', 'plugins'];
+function safeParts(rel) {
+    if (rel.includes('\\') || rel.includes('\0'))
+        throw new Error(`unsafe asset path: ${JSON.stringify(rel)}`);
+    const parts = rel.split('/');
+    if (parts.some(x => !x || x === '.' || x === '..'))
+        throw new Error(`unsafe asset path: ${JSON.stringify(rel)}`);
+    return parts;
+}
+async function assertNoSymlinkParents(root, segments) {
+    let current = root;
+    for (const segment of ['', ...segments.slice(0, -1)]) {
+        if (segment)
+            current = join(current, segment);
+        try {
+            if ((await lstat(current)).isSymbolicLink())
+                throw new Error(`refusing to write asset through symlink: ${current}`);
+        }
+        catch (e) {
+            if (e.code !== 'ENOENT')
+                throw e;
+        }
+    }
+}
 async function walk(dir) {
     const out = [];
     for (const e of await readdir(dir, { withFileTypes: true })) {
@@ -24,7 +48,7 @@ export async function collectAssets(m, p) {
     if (hub) {
         const hubDir = renderPath(hub.dir, p);
         for (const sub of HUB_DIRS) {
-            const root = join(hubDir, sub);
+            const root = join(hubDir, physicalLinkEntry(hub.agent ?? 'claude', sub));
             if (!existsSync(root))
                 continue;
             for (const f of await walk(root)) {
@@ -33,9 +57,10 @@ export async function collectAssets(m, p) {
         }
     }
     for (const pr of m.profiles) {
-        const claudeMd = join(renderPath(pr.dir, p), 'CLAUDE.md');
-        if (existsSync(claudeMd))
-            assets[`profiles/${pr.name}/CLAUDE.md`] = await readFile(claudeMd, 'utf8');
+        const guidanceName = (pr.agent ?? 'claude') === 'codex' ? 'AGENTS.md' : 'CLAUDE.md';
+        const guidance = join(renderPath(pr.dir, p), guidanceName);
+        if (existsSync(guidance))
+            assets[`profiles/${pr.name}/${guidanceName}`] = await readFile(guidance, 'utf8');
     }
     return assets;
 }
@@ -43,14 +68,28 @@ export async function collectAssets(m, p) {
 export async function writeAssets(assets, m, p) {
     const hub = m.profiles.find(x => x.name === m.hub);
     for (const [rel, content] of Object.entries(assets)) {
-        if (rel.startsWith('hub/') && hub) {
-            await atomicWrite(join(renderPath(hub.dir, p), rel.slice('hub/'.length)), content);
+        const parts = safeParts(rel);
+        if (parts[0] === 'hub' && hub) {
+            const [, logicalEntry, ...rest] = parts;
+            if (!HUB_DIRS.includes(logicalEntry) || rest.length === 0)
+                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);
         }
-        else if (rel.startsWith('profiles/')) {
-            const [, name, ...rest] = rel.split('/');
+        else if (parts[0] === 'profiles') {
+            const [, name, ...rest] = parts;
             const pr = m.profiles.find(x => x.name === name);
-            if (pr)
-                await atomicWrite(join(renderPath(pr.dir, p), rest.join('/')), content);
+            if (!pr)
+                throw new Error(`asset references unknown profile: ${name}`);
+            const guidanceName = (pr.agent ?? 'claude') === 'codex' ? 'AGENTS.md' : 'CLAUDE.md';
+            if (rest.length !== 1 || rest[0] !== guidanceName)
+                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);
         }
+        else
+            throw new Error(`unsafe asset path: ${JSON.stringify(rel)}`);
     }
 }

package/dist/codex.d.ts

@@ -0,0 +1,10 @@
+import type { McpServerDef } from './manifest.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
+ * alongside genuine user-scope servers. clp manages user scope only: it neither surfaces
+ * nor manages these project launchers — and (see writeCodexMcpServers) never deletes them.
+ */
+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>;

package/dist/codex.js

@@ -0,0 +1,51 @@
+import { readFile } from 'node:fs/promises';
+import { parse, stringify } from 'smol-toml';
+import { atomicWrite } 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
+ * alongside genuine user-scope servers. clp manages user scope only: it neither surfaces
+ * nor manages these project launchers — and (see writeCodexMcpServers) never deletes them.
+ */
+export function isProjectScopedMcpServer(def) {
+    return !!def.args?.some(a => a === '--project-dir' || a.startsWith('--project-dir='));
+}
+function isMcpServerTable(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value)
+        && (typeof value.command === 'string' || typeof value.url === 'string');
+}
+export async function readCodexMcpServers(configPath) {
+    let config;
+    try {
+        config = parse(await readFile(configPath, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+    const raw = config.mcp_servers;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    return Object.fromEntries(Object.entries(raw)
+        .filter((entry) => isMcpServerTable(entry[1]))
+        // user scope only — hide per-project launchers from the drift matrix, adopt, and sync
+        .filter(([, def]) => !isProjectScopedMcpServer(def)));
+}
+export async function writeCodexMcpServers(configPath, servers) {
+    let config = {};
+    try {
+        config = parse(await readFile(configPath, 'utf8'));
+    }
+    catch { /* new config */ }
+    // 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)
+        ? config.mcp_servers : {};
+    const preserved = Object.fromEntries(Object.entries(existing)
+        .filter((e) => isMcpServerTable(e[1]) && isProjectScopedMcpServer(e[1])));
+    const managed = Object.fromEntries(Object.entries(servers).map(([name, server]) => {
+        const { type: _claudeTransportType, ...codexServer } = server;
+        return [name, codexServer];
+    }));
+    config.mcp_servers = { ...preserved, ...managed };
+    await atomicWrite(configPath, stringify(config));
+}

package/dist/discovery.d.ts

@@ -1,11 +1,14 @@
 import type { McpServerDef } from './manifest.js';
 export interface LiveProfile {
+    agent: 'claude' | 'codex';
     dirName: string;
     dir: string;
     configPath: string;
     account: string | null;
+    authenticated?: boolean;
     mcpServers: Record<string, McpServerDef>;
     links: Record<string, string>;
     settingsEnv: Record<string, string>;
 }
 export declare function discoverProfiles(home: string): Promise<LiveProfile[]>;
+export declare function liveProfileName(lp: Pick<LiveProfile, 'agent' | 'dirName'>): string;

package/dist/discovery.js

@@ -1,49 +1,89 @@
-import { readdir, readFile, readlink } from 'node:fs/promises';
+import { access, readdir, readFile, readlink } from 'node:fs/promises';
 import { join } from 'node:path';
+import { readCodexMcpServers } from './codex.js';
+import { logicalLinkEntry } from './links.js';
 export async function discoverProfiles(home) {
     const entries = await readdir(home, { withFileTypes: true });
     const out = [];
     for (const e of entries) {
-        if (!e.isDirectory() || !(e.name === '.claude' || e.name.startsWith('.claude-')))
+        if (!e.isDirectory())
+            continue;
+        const agent = e.name === '.claude' || e.name.startsWith('.claude-') ? 'claude'
+            : e.name === '.codex' || e.name.startsWith('.codex-') ? 'codex'
+                : null;
+        if (!agent)
             continue;
         const dir = join(home, e.name);
-        const configPath = e.name === '.claude' ? join(home, '.claude.json') : join(dir, '.claude.json');
+        const configPath = agent === 'codex' ? join(dir, 'config.toml')
+            : e.name === '.claude' ? join(home, '.claude.json') : join(dir, '.claude.json');
         let cfg;
-        try {
-            cfg = JSON.parse(await readFile(configPath, 'utf8'));
+        if (agent === 'claude') {
+            try {
+                cfg = JSON.parse(await readFile(configPath, 'utf8'));
+            }
+            catch {
+                continue;
+            }
         }
-        catch {
-            continue;
+        else {
+            let authenticated = false;
+            try {
+                await access(configPath);
+            }
+            catch {
+                try {
+                    await access(join(dir, 'auth.json'));
+                    authenticated = true;
+                }
+                catch {
+                    continue;
+                }
+            }
+            try {
+                await access(join(dir, 'auth.json'));
+                authenticated = true;
+            }
+            catch { /* config-only profile */ }
+            cfg = {};
+            cfg.authenticated = authenticated;
         }
         const links = {};
         for (const child of await readdir(dir, { withFileTypes: true })) {
             if (child.isSymbolicLink()) {
                 try {
                     // windows junctions read back as \\?\C:\... with a trailing separator — normalize
-                    links[child.name] = (await readlink(join(dir, child.name)))
+                    links[logicalLinkEntry(agent, child.name)] = (await readlink(join(dir, child.name)))
                         .replace(/^\\\\\?\\/, '').replace(/([\\/])+$/, '');
                 }
                 catch { /* skip */ }
             }
         }
         const settingsEnv = {};
-        try {
-            const s = JSON.parse(await readFile(join(dir, 'settings.json'), 'utf8'));
-            if (s && typeof s.env === 'object' && s.env !== null)
-                for (const [k, v] of Object.entries(s.env))
-                    if (typeof v === 'string')
-                        settingsEnv[k] = v;
-        }
-        catch { /* no settings.json */ }
+        if (agent === 'claude')
+            try {
+                const s = JSON.parse(await readFile(join(dir, 'settings.json'), 'utf8'));
+                if (s && typeof s.env === 'object' && s.env !== null)
+                    for (const [k, v] of Object.entries(s.env))
+                        if (typeof v === 'string')
+                            settingsEnv[k] = v;
+            }
+            catch { /* no settings.json */ }
         out.push({
+            agent,
             dirName: e.name,
             dir,
             configPath,
-            account: cfg?.oauthAccount?.emailAddress ?? null,
-            mcpServers: cfg?.mcpServers ?? {},
+            account: agent === 'claude' ? cfg?.oauthAccount?.emailAddress ?? null : null,
+            authenticated: agent === 'codex' ? cfg.authenticated : !!cfg?.oauthAccount,
+            mcpServers: agent === 'claude' ? cfg?.mcpServers ?? {} : await readCodexMcpServers(configPath),
             links,
             settingsEnv,
         });
     }
     return out.sort((a, b) => a.dirName.localeCompare(b.dirName));
 }
+export function liveProfileName(lp) {
+    if (lp.agent === 'codex')
+        return lp.dirName === '.codex' ? 'codex' : `codex-${lp.dirName.slice('.codex-'.length)}`;
+    return lp.dirName === '.claude' ? 'default' : lp.dirName.slice('.claude-'.length);
+}

package/dist/fsutil.d.ts

@@ -1,2 +1,3 @@
 export declare function atomicWrite(filePath: string, content: string): 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,4 +1,4 @@
-import { copyFile, mkdir, rename, writeFile } from 'node:fs/promises';
+import { 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) {
@@ -20,3 +20,12 @@ export async function backupFiles(files, backupRoot, stamp) {
     }
     return dir;
 }
+export async function backupTree(src, backupRoot, stamp) {
+    if (!existsSync(src))
+        return null;
+    const dir = join(backupRoot, stamp);
+    const dest = join(dir, sanitize(src));
+    await mkdir(dir, { recursive: true });
+    await cp(src, dest, { recursive: true });
+    return dest;
+}

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './platform.js';
 export * from './manifest.js';
 export * from './discovery.js';
+export * from './codex.js';
 export * from './adopt.js';
 export * from './rcblock.js';
 export * from './fsutil.js';
@@ -8,7 +9,9 @@ export * from './secrets.js';
 export * from './apply.js';
 export * from './crypto.js';
 export * from './assets.js';
+export * from './links.js';
 export * from './devices.js';
 export * from './syncserver.js';
 export * from './syncclient.js';
 export * from './bundle.js';
+export * from './sessions.js';

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from './platform.js';
 export * from './manifest.js';
 export * from './discovery.js';
+export * from './codex.js';
 export * from './adopt.js';
 export * from './rcblock.js';
 export * from './fsutil.js';
@@ -8,7 +9,9 @@ export * from './secrets.js';
 export * from './apply.js';
 export * from './crypto.js';
 export * from './assets.js';
+export * from './links.js';
 export * from './devices.js';
 export * from './syncserver.js';
 export * from './syncclient.js';
 export * from './bundle.js';
+export * from './sessions.js';

package/dist/links.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Manifest links use agent-neutral names. Translate only at filesystem edge so
+ * one `commands: hub` declaration works for Claude Code and Codex profiles.
+ */
+export declare function physicalLinkEntry(agent: 'claude' | 'codex', entry: string): string;
+/** Convert discovered filesystem entry back to agent-neutral manifest name. */
+export declare function logicalLinkEntry(agent: 'claude' | 'codex', entry: string): string;

package/dist/links.js

@@ -0,0 +1,11 @@
+/**
+ * Manifest links use agent-neutral names. Translate only at filesystem edge so
+ * one `commands: hub` declaration works for Claude Code and Codex profiles.
+ */
+export function physicalLinkEntry(agent, entry) {
+    return agent === 'codex' && entry === 'commands' ? 'prompts' : entry;
+}
+/** Convert discovered filesystem entry back to agent-neutral manifest name. */
+export function logicalLinkEntry(agent, entry) {
+    return agent === 'codex' && entry === 'prompts' ? 'commands' : entry;
+}

package/dist/manifest.d.ts

@@ -33,6 +33,7 @@ declare const McpServerSchema: z.ZodEffects<z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
 }, z.ZodTypeAny, "passthrough">>;
 declare const ProfileSchema: z.ZodObject<{
+    agent: z.ZodOptional<z.ZodEnum<["claude", "codex"]>>;
     name: z.ZodString;
     dir: z.ZodString;
     launcher: z.ZodNullable<z.ZodString>;
@@ -42,6 +43,7 @@ declare const ProfileSchema: z.ZodObject<{
     mcp: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     settingsEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     skipPermissions: z.ZodDefault<z.ZodBoolean>;
+    sharedSessions: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     env: Record<string, string>;
     name: string;
@@ -52,21 +54,26 @@ declare const ProfileSchema: z.ZodObject<{
     mcp: string[];
     settingsEnv: Record<string, string>;
     skipPermissions: boolean;
+    sharedSessions: boolean;
+    agent?: "claude" | "codex" | undefined;
 }, {
     name: string;
     dir: string;
     launcher: string | null;
     auth: "env" | "oauth" | "api-key";
     env?: Record<string, string> | undefined;
+    agent?: "claude" | "codex" | undefined;
     links?: Record<string, string> | undefined;
     mcp?: string[] | undefined;
     settingsEnv?: Record<string, string> | undefined;
     skipPermissions?: boolean | undefined;
+    sharedSessions?: boolean | undefined;
 }>;
 declare const ManifestSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     hub: z.ZodNullable<z.ZodString>;
     profiles: z.ZodArray<z.ZodObject<{
+        agent: z.ZodOptional<z.ZodEnum<["claude", "codex"]>>;
         name: z.ZodString;
         dir: z.ZodString;
         launcher: z.ZodNullable<z.ZodString>;
@@ -76,6 +83,7 @@ declare const ManifestSchema: z.ZodObject<{
         mcp: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         settingsEnv: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
         skipPermissions: z.ZodDefault<z.ZodBoolean>;
+        sharedSessions: z.ZodDefault<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         env: Record<string, string>;
         name: string;
@@ -86,16 +94,20 @@ declare const ManifestSchema: z.ZodObject<{
         mcp: string[];
         settingsEnv: Record<string, string>;
         skipPermissions: boolean;
+        sharedSessions: boolean;
+        agent?: "claude" | "codex" | undefined;
     }, {
         name: string;
         dir: string;
         launcher: string | null;
         auth: "env" | "oauth" | "api-key";
         env?: Record<string, string> | undefined;
+        agent?: "claude" | "codex" | undefined;
         links?: Record<string, string> | undefined;
         mcp?: string[] | undefined;
         settingsEnv?: Record<string, string> | undefined;
         skipPermissions?: boolean | undefined;
+        sharedSessions?: boolean | undefined;
     }>, "many">;
     mcpServers: z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodObject<{
         command: z.ZodOptional<z.ZodString>;
@@ -141,6 +153,8 @@ declare const ManifestSchema: z.ZodObject<{
         mcp: string[];
         settingsEnv: Record<string, string>;
         skipPermissions: boolean;
+        sharedSessions: boolean;
+        agent?: "claude" | "codex" | undefined;
     }[];
     mcpServers: Record<string, z.objectOutputType<{
         command: z.ZodOptional<z.ZodString>;
@@ -158,10 +172,12 @@ declare const ManifestSchema: z.ZodObject<{
         launcher: string | null;
         auth: "env" | "oauth" | "api-key";
         env?: Record<string, string> | undefined;
+        agent?: "claude" | "codex" | undefined;
         links?: Record<string, string> | undefined;
         mcp?: string[] | undefined;
         settingsEnv?: Record<string, string> | undefined;
         skipPermissions?: boolean | undefined;
+        sharedSessions?: boolean | undefined;
     }[];
     mcpServers: Record<string, z.objectInputType<{
         command: z.ZodOptional<z.ZodString>;

package/dist/manifest.js

@@ -15,6 +15,7 @@ const McpServerSchema = z.object({
     url: z.string().optional(),
 }).passthrough().refine(s => s.command !== undefined || s.url !== undefined, { message: 'mcp server must have either "command" (local) or "url" (remote)' });
 const ProfileSchema = z.object({
+    agent: z.enum(['claude', 'codex']).optional(),
     name: z.string().min(1),
     dir: z.string().min(1),
     launcher: z.string().nullable(),
@@ -24,6 +25,7 @@ const ProfileSchema = z.object({
     mcp: z.array(z.string()).default([]),
     settingsEnv: z.record(z.string()).default({}),
     skipPermissions: z.boolean().default(false),
+    sharedSessions: z.boolean().default(false),
 });
 const ManifestSchema = z.object({
     version: z.literal(1),
@@ -34,6 +36,7 @@ const ManifestSchema = z.object({
 // identifiers that get interpolated into shell launcher code must be injection-safe
 const SAFE_NAME = /^[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 SHELL_META = /["`$;|&()\n\r<>]/; // chars that could break out of a quoted shell context
 const SECRET_PREFIX = 'secret://';
 /**
@@ -67,6 +70,10 @@ export function assertSafeManifest(m) {
                     throw new ManifestError(`unsafe secret reference in profile "${p.name}": ${JSON.stringify(v)}`);
             }
         }
+        for (const entry of Object.keys(p.links)) {
+            if (!SAFE_LINK_ENTRY.test(entry) || entry === '.' || entry === '..')
+                throw new ManifestError(`unsafe link entry in profile "${p.name}": ${JSON.stringify(entry)} (must be one file or directory name)`);
+        }
     }
 }
 export function parseManifest(text) {

package/dist/rcblock.js

@@ -23,8 +23,11 @@ function renderPosix(pr, p) {
             ? `  export ${k}="$(ccprofiles secrets get ${v.slice(SECRET_PREFIX.length)})"`
             : `  export ${k}="${escapePosix(v)}"`);
     }
-    const flag = pr.skipPermissions ? ' --dangerously-skip-permissions' : '';
-    lines.push(`  CLAUDE_CONFIG_DIR="${profileDirExpr(pr, p)}" claude${flag} "$@"`, '}');
+    const codex = (pr.agent ?? 'claude') === 'codex';
+    const flag = pr.skipPermissions ? codex ? ' --dangerously-bypass-approvals-and-sandbox' : ' --dangerously-skip-permissions' : '';
+    const home = codex ? 'CODEX_HOME' : 'CLAUDE_CONFIG_DIR';
+    const command = codex ? 'codex' : 'claude';
+    lines.push(`  ${home}="${profileDirExpr(pr, p)}" ${command}${flag} "$@"`, '}');
     return lines.join('\n');
 }
 function renderPwsh(pr, p) {
@@ -34,8 +37,11 @@ function renderPwsh(pr, p) {
             ? `  $env:${k} = (ccprofiles secrets get ${v.slice(SECRET_PREFIX.length)})`
             : `  $env:${k} = "${escapePwsh(v)}"`);
     }
-    const flag = pr.skipPermissions ? ' --dangerously-skip-permissions' : '';
-    lines.push(`  $env:CLAUDE_CONFIG_DIR = "${profileDirExpr(pr, p)}"`, `  claude${flag} @args`, '}');
+    const codex = (pr.agent ?? 'claude') === 'codex';
+    const flag = pr.skipPermissions ? codex ? ' --dangerously-bypass-approvals-and-sandbox' : ' --dangerously-skip-permissions' : '';
+    const home = codex ? 'CODEX_HOME' : 'CLAUDE_CONFIG_DIR';
+    const command = codex ? 'codex' : 'claude';
+    lines.push(`  $env:${home} = "${profileDirExpr(pr, p)}"`, `  ${command}${flag} @args`, '}');
     return lines.join('\n');
 }
 export function renderRcBlock(m, p) {

package/dist/sessions.d.ts

@@ -0,0 +1,25 @@
+export interface SessionMeta {
+    id: string;
+    mtime: number;
+    messageCount: number;
+    firstPrompt: string | null;
+    gitBranch: string | null;
+    model: string | null;
+    sizeBytes: number;
+}
+export interface ProjectSessions {
+    agent: 'claude' | 'codex';
+    scope: string;
+    project: string;
+    sessions: SessionMeta[];
+}
+/** Best-effort decode of Claude Code's project dir name (cwd from a record is preferred). */
+export declare function decodeProjectDir(name: string): string;
+export declare function scanSessions(opts: {
+    sharedRoot: string;
+    profiles: {
+        name: string;
+        dir: string;
+        agent?: 'claude' | 'codex';
+    }[];
+}): Promise<ProjectSessions[]>;

package/dist/sessions.js

@@ -0,0 +1,202 @@
+import { readdir, readFile, stat, lstat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+/** Best-effort decode of Claude Code's project dir name (cwd from a record is preferred). */
+export function decodeProjectDir(name) {
+    return name.replace(/^-/, '/').replace(/-/g, '/');
+}
+async function parseClaudeSession(file) {
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const st = await stat(file);
+    const lines = raw.split('\n').filter(l => l.trim());
+    let firstPrompt = null, gitBranch = null, model = null, cwd = null;
+    for (const line of lines) {
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (cwd === null && typeof rec.cwd === 'string')
+            cwd = rec.cwd;
+        if (gitBranch === null && typeof rec.gitBranch === 'string')
+            gitBranch = rec.gitBranch;
+        if (firstPrompt === null && rec.type === 'user') {
+            const c = rec.message?.content;
+            const text = typeof c === 'string' ? c : Array.isArray(c) ? c.find((x) => x?.type === 'text')?.text : null;
+            if (typeof text === 'string' && text.trim() && !text.trimStart().startsWith('<'))
+                firstPrompt = text.trim().slice(0, 200);
+        }
+        if (model === null && typeof rec.message?.model === 'string')
+            model = rec.message.model;
+        if (firstPrompt && model && gitBranch && cwd)
+            break;
+    }
+    const id = file.split(/[\\/]/).pop().replace(/\.jsonl$/, '');
+    return { meta: { id, mtime: st.mtimeMs, messageCount: lines.length, firstPrompt, gitBranch, model, sizeBytes: st.size }, cwd };
+}
+async function scanProjectsDir(projectsDir, scope) {
+    if (!existsSync(projectsDir))
+        return [];
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(projectsDir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const proj of entries) {
+        if (!proj.isDirectory())
+            continue;
+        const pdir = join(projectsDir, proj.name);
+        const sessions = [];
+        let cwd = null;
+        let files;
+        try {
+            files = await readdir(pdir);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!f.endsWith('.jsonl'))
+                continue;
+            const parsed = await parseClaudeSession(join(pdir, f));
+            if (!parsed)
+                continue;
+            sessions.push(parsed.meta);
+            if (cwd === null)
+                cwd = parsed.cwd;
+        }
+        if (!sessions.length)
+            continue;
+        sessions.sort((a, b) => b.mtime - a.mtime);
+        out.push({ agent: 'claude', scope, project: cwd ?? decodeProjectDir(proj.name), sessions });
+    }
+    return out;
+}
+function messageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return null;
+    const item = content.find((x) => x?.type === 'input_text' || x?.type === 'text');
+    return typeof item?.text === 'string' ? item.text : null;
+}
+async function parseCodexSession(file) {
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const st = await stat(file);
+    const lines = raw.split('\n').filter(l => l.trim());
+    let id = null, firstPrompt = null, gitBranch = null;
+    let model = null, cwd = null, messageCount = 0;
+    for (const line of lines) {
+        let rec;
+        try {
+            rec = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const payload = rec?.payload;
+        if (rec?.type === 'session_meta') {
+            if (typeof payload?.id === 'string')
+                id = payload.id;
+            else if (typeof payload?.session_id === 'string')
+                id = payload.session_id;
+            if (typeof payload?.cwd === 'string')
+                cwd = payload.cwd;
+            if (typeof payload?.git?.branch === 'string')
+                gitBranch = payload.git.branch;
+        }
+        if (rec?.type === 'turn_context') {
+            if (cwd === null && typeof payload?.cwd === 'string')
+                cwd = payload.cwd;
+            if (model === null && typeof payload?.model === 'string')
+                model = payload.model;
+        }
+        if (rec?.type === 'response_item' && payload?.type === 'message'
+            && (payload?.role === 'user' || payload?.role === 'assistant')) {
+            messageCount++;
+            if (firstPrompt === null && payload.role === 'user') {
+                const text = messageText(payload.content);
+                if (text?.trim() && !text.trimStart().startsWith('<'))
+                    firstPrompt = text.trim().slice(0, 200);
+            }
+        }
+        if (firstPrompt === null && rec?.type === 'event_msg' && payload?.type === 'user_message'
+            && typeof payload?.message === 'string' && payload.message.trim()) {
+            firstPrompt = payload.message.trim().slice(0, 200);
+        }
+    }
+    const filename = file.split(/[\\/]/).pop().replace(/\.jsonl$/, '');
+    id ??= filename.match(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i)?.[0] ?? filename;
+    return { meta: { id, mtime: st.mtimeMs, messageCount: messageCount || lines.length, firstPrompt, gitBranch, model, sizeBytes: st.size }, cwd };
+}
+async function codexSessionFiles(dir) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory())
+            out.push(...await codexSessionFiles(path));
+        else if (entry.isFile() && entry.name.endsWith('.jsonl'))
+            out.push(path);
+    }
+    return out;
+}
+async function scanCodexSessionsDir(sessionsDir, scope) {
+    const byProject = new Map();
+    for (const file of await codexSessionFiles(sessionsDir)) {
+        const parsed = await parseCodexSession(file);
+        if (!parsed)
+            continue;
+        const project = parsed.cwd ?? '(unknown project)';
+        const sessions = byProject.get(project) ?? [];
+        sessions.push(parsed.meta);
+        byProject.set(project, sessions);
+    }
+    return [...byProject.entries()].map(([project, sessions]) => ({
+        agent: 'codex', scope, project,
+        sessions: sessions.sort((a, b) => b.mtime - a.mtime),
+    }));
+}
+export async function scanSessions(opts) {
+    const out = [];
+    out.push(...await scanProjectsDir(join(opts.sharedRoot, 'projects'), 'shared'));
+    out.push(...await scanCodexSessionsDir(join(opts.sharedRoot, 'sessions'), 'shared'));
+    for (const p of opts.profiles) {
+        const agent = p.agent ?? 'claude';
+        const sessionDir = join(p.dir, agent === 'codex' ? 'sessions' : 'projects');
+        try {
+            if ((await lstat(sessionDir)).isSymbolicLink())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        out.push(...agent === 'codex'
+            ? await scanCodexSessionsDir(sessionDir, p.name)
+            : await scanProjectsDir(sessionDir, p.name));
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccprofiles-core",
-  "version": "0.4.0",
+  "version": "0.5.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",
@@ -27,6 +27,7 @@
     "node": ">=20"
   },
   "dependencies": {
+    "smol-toml": "^1.7.0",
     "yaml": "^2.5.0",
     "zod": "^3.23.0"
   }