ccprofiles-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ccprofiles contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adopt.d.ts

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,38 @@
+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)
+        for (const [name, def] of Object.entries(lp.mcpServers))
+            mcpServers[name] ??= def;
+    // hub = profile whose dir is the most common link target prefix
+    const linkVotes = new Map();
+    for (const lp of live)
+        for (const target of Object.values(lp.links)) {
+            const owner = live.find(o => o !== lp && target.startsWith(o.dir));
+            if (owner)
+                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 profiles = live.map(lp => {
+        const name = profileName(lp.dirName);
+        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 {
+            name,
+            dir: toTemplate(lp.dir, platform),
+            launcher: name === 'default' ? null : `cl-${name}`,
+            auth: lp.account ? 'oauth' : 'env',
+            env: {},
+            links,
+            mcp: Object.keys(lp.mcpServers).sort(),
+        };
+    });
+    return { version: 1, hub, profiles, mcpServers };
+}

package/dist/apply.d.ts

@@ -0,0 +1,28 @@
+import type { Manifest, McpServerDef } from './manifest.js';
+import type { LiveProfile } from './discovery.js';
+import { type Platform } from './platform.js';
+export type ApplyAction = {
+    kind: 'set-mcp-servers';
+    configPath: string;
+    servers: Record<string, McpServerDef>;
+} | {
+    kind: 'create-profile-dir';
+    dir: string;
+} | {
+    kind: 'link';
+    from: string;
+    to: string;
+} | {
+    kind: 'rc-block';
+    rcFile: string;
+    block: string;
+};
+export declare function planApply(m: Manifest, live: LiveProfile[], p: Platform): ApplyAction[];
+export declare function executeApply(actions: ApplyAction[], opts: {
+    backupRoot: string;
+    stamp: string;
+    dryRun?: boolean;
+}): Promise<{
+    backupDir: string | null;
+    performed: string[];
+}>;

package/dist/apply.js

@@ -0,0 +1,102 @@
+import { lstat, mkdir, readFile, symlink, unlink } from 'node:fs/promises';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { renderPath } from './platform.js';
+import { renderRcBlock, upsertManagedBlock } from './rcblock.js';
+import { atomicWrite, backupFiles } from './fsutil.js';
+function configPathFor(dir, home) {
+    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)));
+}
+export function planApply(m, live, p) {
+    const actions = [];
+    const hubProfile = m.profiles.find(x => x.name === m.hub) ?? null;
+    for (const pr of m.profiles) {
+        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];
+        if (!lp)
+            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 });
+        }
+        for (const [entry, target] of Object.entries(pr.links)) {
+            const to = target === 'hub' && hubProfile
+                ? join(renderPath(hubProfile.dir, p), entry)
+                : renderPath(target, p);
+            const from = join(dir, entry);
+            if (lp?.links[entry] === to)
+                continue;
+            actions.push({ kind: 'link', from, to });
+        }
+    }
+    const block = renderRcBlock(m, p);
+    let rcCurrent = '';
+    try {
+        rcCurrent = existsSync(p.rcFile) ? readFileSync(p.rcFile, 'utf8') : '';
+    }
+    catch { /* treat as empty */ }
+    if (!rcCurrent.includes(block))
+        actions.push({ kind: 'rc-block', rcFile: p.rcFile, block });
+    return actions;
+}
+export async function executeApply(actions, opts) {
+    const performed = actions.map(describe);
+    if (opts.dryRun)
+        return { backupDir: null, performed };
+    const touched = actions.flatMap(a => a.kind === 'set-mcp-servers' ? [a.configPath] : a.kind === 'rc-block' ? [a.rcFile] : []);
+    const 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') {
+            let cfg = {};
+            try {
+                cfg = JSON.parse(await readFile(a.configPath, 'utf8'));
+            }
+            catch { /* new file */ }
+            cfg.mcpServers = a.servers;
+            await mkdir(dirname(a.configPath), { recursive: true });
+            await atomicWrite(a.configPath, JSON.stringify(cfg, null, 2));
+        }
+        else if (a.kind === 'link') {
+            try {
+                const st = await lstat(a.from);
+                if (!st.isSymbolicLink())
+                    throw new Error(`refusing to replace non-symlink: ${a.from}`);
+                await unlink(a.from);
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT') {
+                    if (typeof e.message === 'string' && e.message.startsWith('refusing'))
+                        throw e;
+                }
+            }
+            await symlink(a.to, a.from, process.platform === 'win32' ? 'junction' : 'dir');
+        }
+        else if (a.kind === 'rc-block') {
+            let rc = '';
+            try {
+                rc = await readFile(a.rcFile, 'utf8');
+            }
+            catch { /* new file */ }
+            await mkdir(dirname(a.rcFile), { recursive: true });
+            await atomicWrite(a.rcFile, upsertManagedBlock(rc, a.block));
+        }
+    }
+    return { backupDir, performed };
+}
+function describe(a) {
+    switch (a.kind) {
+        case 'set-mcp-servers': return `set mcpServers (${Object.keys(a.servers).length}) in ${a.configPath}`;
+        case 'create-profile-dir': return `create ${a.dir}`;
+        case 'link': return `link ${a.from} -> ${a.to}`;
+        case 'rc-block': return `update managed block in ${a.rcFile}`;
+    }
+}

package/dist/assets.d.ts

@@ -0,0 +1,6 @@
+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>;

package/dist/assets.js

@@ -0,0 +1,56 @@
+import { 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'];
+async function walk(dir) {
+    const out = [];
+    for (const e of await readdir(dir, { withFileTypes: true })) {
+        const p = join(dir, e.name);
+        if (e.isSymbolicLink())
+            continue;
+        if (e.isDirectory())
+            out.push(...await walk(p));
+        else
+            out.push(p);
+    }
+    return out;
+}
+/** Collect shareable assets as a relative-path → utf8-content map. */
+export async function collectAssets(m, p) {
+    const assets = {};
+    const hub = m.profiles.find(x => x.name === m.hub);
+    if (hub) {
+        const hubDir = renderPath(hub.dir, p);
+        for (const sub of HUB_DIRS) {
+            const root = join(hubDir, sub);
+            if (!existsSync(root))
+                continue;
+            for (const f of await walk(root)) {
+                assets[`hub/${sub}/${relative(root, f).split('\\').join('/')}`] = await readFile(f, 'utf8');
+            }
+        }
+    }
+    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');
+    }
+    return assets;
+}
+/** Write an asset map back to the live layout. */
+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);
+        }
+        else if (rel.startsWith('profiles/')) {
+            const [, name, ...rest] = rel.split('/');
+            const pr = m.profiles.find(x => x.name === name);
+            if (pr)
+                await atomicWrite(join(renderPath(pr.dir, p), rest.join('/')), content);
+        }
+    }
+}

package/dist/bundle.d.ts

@@ -0,0 +1,7 @@
+export interface Bundle {
+    v: 1;
+    manifestYaml: string;
+    assets: Record<string, string>;
+}
+export declare function exportBundle(manifestYaml: string, assets: Record<string, string>): Buffer;
+export declare function importBundle(buf: Buffer): Bundle;

package/dist/bundle.js

@@ -0,0 +1,16 @@
+import { gzipSync, gunzipSync } from 'node:zlib';
+export function exportBundle(manifestYaml, assets) {
+    return gzipSync(JSON.stringify({ v: 1, manifestYaml, assets }));
+}
+export function importBundle(buf) {
+    let parsed;
+    try {
+        parsed = JSON.parse(gunzipSync(buf).toString('utf8'));
+    }
+    catch {
+        throw new Error('not a ccprofiles bundle (expected a file created by: ccp export)');
+    }
+    if (parsed?.v !== 1 || typeof parsed.manifestYaml !== 'string')
+        throw new Error('not a ccprofiles bundle (expected a file created by: ccp export)');
+    return parsed;
+}

package/dist/crypto.d.ts

@@ -0,0 +1,20 @@
+import { type KeyObject } from 'node:crypto';
+export interface Sealed {
+    iv: string;
+    tag: string;
+    data: string;
+}
+/** X25519 keypair for the pairing handshake. */
+export declare function handshakeKeys(): {
+    privateKey: KeyObject;
+    publicRaw: string;
+};
+/** ECDH(private, peerPublic) → HKDF-SHA256 with salt → 32-byte key. */
+export declare function deriveSharedKey(privateKey: KeyObject, peerPublicRaw: string, salt: string): Buffer;
+export declare function sealJson(key: Buffer, obj: unknown): Sealed;
+export declare function openJson<T = unknown>(key: Buffer, sealed: Sealed): T;
+/** PIN-bound confirmation MAC over the handshake — proves both sides know the PIN. */
+export declare function pinMac(key: Buffer, role: 'client' | 'server', pin: string): string;
+export declare function newSalt(): string;
+export declare function newToken(): string;
+export declare function newPin(): string;

package/dist/crypto.js

@@ -0,0 +1,32 @@
+import { createCipheriv, createDecipheriv, createHmac, createPublicKey, diffieHellman, generateKeyPairSync, hkdfSync, randomBytes, } from 'node:crypto';
+/** X25519 keypair for the pairing handshake. */
+export function handshakeKeys() {
+    const { privateKey, publicKey } = generateKeyPairSync('x25519');
+    const raw = publicKey.export({ type: 'spki', format: 'der' }).toString('base64');
+    return { privateKey, publicRaw: raw };
+}
+/** ECDH(private, peerPublic) → HKDF-SHA256 with salt → 32-byte key. */
+export function deriveSharedKey(privateKey, peerPublicRaw, salt) {
+    const peer = createPublicKey({ key: Buffer.from(peerPublicRaw, 'base64'), type: 'spki', format: 'der' });
+    const secret = diffieHellman({ privateKey, publicKey: peer });
+    return Buffer.from(hkdfSync('sha256', secret, Buffer.from(salt, 'base64'), 'ccprofiles-pairing', 32));
+}
+export function sealJson(key, obj) {
+    const iv = randomBytes(12);
+    const c = createCipheriv('aes-256-gcm', key, iv);
+    const data = Buffer.concat([c.update(JSON.stringify(obj), 'utf8'), c.final()]);
+    return { iv: iv.toString('base64'), tag: c.getAuthTag().toString('base64'), data: data.toString('base64') };
+}
+export function openJson(key, sealed) {
+    const d = createDecipheriv('aes-256-gcm', key, Buffer.from(sealed.iv, 'base64'));
+    d.setAuthTag(Buffer.from(sealed.tag, 'base64'));
+    const text = d.update(Buffer.from(sealed.data, 'base64')).toString('utf8') + d.final('utf8');
+    return JSON.parse(text);
+}
+/** PIN-bound confirmation MAC over the handshake — proves both sides know the PIN. */
+export function pinMac(key, role, pin) {
+    return createHmac('sha256', key).update(`ccprofiles:${role}:${pin}`).digest('base64');
+}
+export function newSalt() { return randomBytes(16).toString('base64'); }
+export function newToken() { return randomBytes(32).toString('base64url'); }
+export function newPin() { return String(Math.floor(100000 + Math.random() * 900000)); }

package/dist/devices.d.ts

@@ -0,0 +1,12 @@
+export interface DeviceEntry {
+    name: string;
+    host: string;
+    port: number;
+    token: string;
+    /** base64 pairing key — encrypts all traffic with this peer */
+    key: string;
+}
+export declare function loadDevices(root: string): Promise<DeviceEntry[]>;
+export declare function saveDevices(root: string, list: DeviceEntry[]): Promise<void>;
+/** Keep secret-bearing files out of the manifest repo's auto-commits. */
+export declare function ensureRootGitignore(root: string): Promise<void>;

package/dist/devices.js

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { atomicWrite } from './fsutil.js';
+const IGNORE = ['secrets.enc', 'secret-names.json', 'devices.json', 'backups/', '*.ccp-tmp'];
+export async function loadDevices(root) {
+    const f = join(root, 'devices.json');
+    if (!existsSync(f))
+        return [];
+    return JSON.parse(await readFile(f, 'utf8'));
+}
+export async function saveDevices(root, list) {
+    await atomicWrite(join(root, 'devices.json'), JSON.stringify(list, null, 2));
+}
+/** Keep secret-bearing files out of the manifest repo's auto-commits. */
+export async function ensureRootGitignore(root) {
+    const f = join(root, '.gitignore');
+    const current = existsSync(f) ? await readFile(f, 'utf8') : '';
+    const missing = IGNORE.filter(l => !current.split('\n').includes(l));
+    if (missing.length)
+        await atomicWrite(f, current + (current && !current.endsWith('\n') ? '\n' : '') + missing.join('\n') + '\n');
+}

package/dist/discovery.d.ts

@@ -0,0 +1,10 @@
+import type { McpServerDef } from './manifest.js';
+export interface LiveProfile {
+    dirName: string;
+    dir: string;
+    configPath: string;
+    account: string | null;
+    mcpServers: Record<string, McpServerDef>;
+    links: Record<string, string>;
+}
+export declare function discoverProfiles(home: string): Promise<LiveProfile[]>;

package/dist/discovery.js

@@ -0,0 +1,39 @@
+import { readdir, readFile, readlink } from 'node:fs/promises';
+import { join } from 'node:path';
+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-')))
+            continue;
+        const dir = join(home, e.name);
+        const configPath = e.name === '.claude' ? join(home, '.claude.json') : join(dir, '.claude.json');
+        let cfg;
+        try {
+            cfg = JSON.parse(await readFile(configPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        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)))
+                        .replace(/^\\\\\?\\/, '').replace(/([\\/])+$/, '');
+                }
+                catch { /* skip */ }
+            }
+        }
+        out.push({
+            dirName: e.name,
+            dir,
+            configPath,
+            account: cfg?.oauthAccount?.emailAddress ?? null,
+            mcpServers: cfg?.mcpServers ?? {},
+            links,
+        });
+    }
+    return out.sort((a, b) => a.dirName.localeCompare(b.dirName));
+}

package/dist/fsutil.d.ts

@@ -0,0 +1,2 @@
+export declare function atomicWrite(filePath: string, content: string): Promise<void>;
+export declare function backupFiles(files: string[], backupRoot: string, stamp: string): Promise<string>;

package/dist/fsutil.js

@@ -0,0 +1,22 @@
+import { copyFile, 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 });
+    const tmp = `${filePath}.ccp-tmp`;
+    await writeFile(tmp, content, 'utf8');
+    await rename(tmp, filePath);
+}
+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 });
+    for (const f of files) {
+        if (!existsSync(f))
+            continue;
+        await copyFile(f, join(dir, sanitize(f)));
+    }
+    return dir;
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './platform.js';
+export * from './manifest.js';
+export * from './discovery.js';
+export * from './adopt.js';
+export * from './rcblock.js';
+export * from './fsutil.js';
+export * from './secrets.js';
+export * from './apply.js';
+export * from './crypto.js';
+export * from './assets.js';
+export * from './devices.js';
+export * from './syncserver.js';
+export * from './syncclient.js';
+export * from './bundle.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './platform.js';
+export * from './manifest.js';
+export * from './discovery.js';
+export * from './adopt.js';
+export * from './rcblock.js';
+export * from './fsutil.js';
+export * from './secrets.js';
+export * from './apply.js';
+export * from './crypto.js';
+export * from './assets.js';
+export * from './devices.js';
+export * from './syncserver.js';
+export * from './syncclient.js';
+export * from './bundle.js';

package/dist/manifest.d.ts

@@ -0,0 +1,147 @@
+import { z } from 'zod';
+export declare class ManifestError extends Error {
+}
+declare const McpServerSchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    type: z.ZodOptional<z.ZodString>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const ProfileSchema: z.ZodObject<{
+    name: z.ZodString;
+    dir: z.ZodString;
+    launcher: z.ZodNullable<z.ZodString>;
+    auth: z.ZodEnum<["oauth", "api-key", "env"]>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    links: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    mcp: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    env: Record<string, string>;
+    name: string;
+    dir: string;
+    launcher: string | null;
+    auth: "env" | "oauth" | "api-key";
+    links: Record<string, string>;
+    mcp: string[];
+}, {
+    name: string;
+    dir: string;
+    launcher: string | null;
+    auth: "env" | "oauth" | "api-key";
+    env?: Record<string, string> | undefined;
+    links?: Record<string, string> | undefined;
+    mcp?: string[] | undefined;
+}>;
+declare const ManifestSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    hub: z.ZodNullable<z.ZodString>;
+    profiles: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        dir: z.ZodString;
+        launcher: z.ZodNullable<z.ZodString>;
+        auth: z.ZodEnum<["oauth", "api-key", "env"]>;
+        env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        links: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+        mcp: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        env: Record<string, string>;
+        name: string;
+        dir: string;
+        launcher: string | null;
+        auth: "env" | "oauth" | "api-key";
+        links: Record<string, string>;
+        mcp: string[];
+    }, {
+        name: string;
+        dir: string;
+        launcher: string | null;
+        auth: "env" | "oauth" | "api-key";
+        env?: Record<string, string> | undefined;
+        links?: Record<string, string> | undefined;
+        mcp?: string[] | undefined;
+    }>, "many">;
+    mcpServers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    hub: string | null;
+    profiles: {
+        env: Record<string, string>;
+        name: string;
+        dir: string;
+        launcher: string | null;
+        auth: "env" | "oauth" | "api-key";
+        links: Record<string, string>;
+        mcp: string[];
+    }[];
+    mcpServers: Record<string, z.objectOutputType<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+}, {
+    version: 1;
+    hub: string | null;
+    profiles: {
+        name: string;
+        dir: string;
+        launcher: string | null;
+        auth: "env" | "oauth" | "api-key";
+        env?: Record<string, string> | undefined;
+        links?: Record<string, string> | undefined;
+        mcp?: string[] | undefined;
+    }[];
+    mcpServers: Record<string, z.objectInputType<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        type: z.ZodOptional<z.ZodString>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>;
+}>;
+export type McpServerDef = z.infer<typeof McpServerSchema>;
+export type ProfileDecl = z.infer<typeof ProfileSchema>;
+export type Manifest = z.infer<typeof ManifestSchema>;
+/**
+ * Reject manifests whose identifiers could break out of the shell launcher context.
+ * Applies to every manifest — an untrusted bundle/peer manifest reaches this before
+ * anything is written to your rc file or config.
+ */
+export declare function assertSafeManifest(m: Manifest): void;
+export declare function parseManifest(text: string): Manifest;
+export declare function serializeManifest(m: Manifest): string;
+export declare function loadManifest(root: string): Promise<Manifest>;
+export declare function saveManifest(root: string, m: Manifest): Promise<void>;
+export {};

package/dist/manifest.js

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import YAML from 'yaml';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+export class ManifestError extends Error {
+}
+const McpServerSchema = z.object({
+    command: z.string(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string()).optional(),
+    type: z.string().optional(),
+    url: z.string().optional(),
+}).passthrough();
+const ProfileSchema = z.object({
+    name: z.string().min(1),
+    dir: z.string().min(1),
+    launcher: z.string().nullable(),
+    auth: z.enum(['oauth', 'api-key', 'env']),
+    env: z.record(z.string()).default({}),
+    links: z.record(z.string()).default({}),
+    mcp: z.array(z.string()).default([]),
+});
+const ManifestSchema = z.object({
+    version: z.literal(1),
+    hub: z.string().nullable(),
+    profiles: z.array(ProfileSchema),
+    mcpServers: z.record(McpServerSchema),
+});
+// 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 SHELL_META = /["`$;|&()\n\r<>]/; // chars that could break out of a quoted shell context
+const SECRET_PREFIX = 'secret://';
+/**
+ * Reject manifests whose identifiers could break out of the shell launcher context.
+ * Applies to every manifest — an untrusted bundle/peer manifest reaches this before
+ * anything is written to your rc file or config.
+ */
+export function assertSafeManifest(m) {
+    for (const p of m.profiles) {
+        if (!SAFE_NAME.test(p.name))
+            throw new ManifestError(`unsafe profile name: ${JSON.stringify(p.name)} (allowed: letters, digits, - _)`);
+        if (p.launcher !== null && !SAFE_NAME.test(p.launcher))
+            throw new ManifestError(`unsafe launcher name in profile "${p.name}": ${JSON.stringify(p.launcher)}`);
+        if (SHELL_META.test(p.dir))
+            throw new ManifestError(`unsafe profile dir in profile "${p.name}": ${JSON.stringify(p.dir)}`);
+        for (const [k, v] of Object.entries(p.env)) {
+            if (!SAFE_ENV_KEY.test(k))
+                throw new ManifestError(`unsafe env var name in profile "${p.name}": ${JSON.stringify(k)}`);
+            if (v.startsWith(SECRET_PREFIX)) {
+                const ref = v.slice(SECRET_PREFIX.length);
+                if (!SAFE_NAME.test(ref))
+                    throw new ManifestError(`unsafe secret reference in profile "${p.name}": ${JSON.stringify(v)}`);
+            }
+        }
+    }
+}
+export function parseManifest(text) {
+    let raw;
+    try {
+        raw = YAML.parse(text);
+    }
+    catch (e) {
+        throw new ManifestError(`invalid yaml: ${e.message}`);
+    }
+    const res = ManifestSchema.safeParse(raw);
+    if (!res.success)
+        throw new ManifestError(res.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join('; '));
+    const m = res.data;
+    for (const p of m.profiles)
+        for (const name of p.mcp)
+            if (!m.mcpServers[name])
+                throw new ManifestError(`profile "${p.name}" references undefined mcp server "${name}"`);
+    assertSafeManifest(m);
+    return m;
+}
+export function serializeManifest(m) {
+    return YAML.stringify(m);
+}
+export async function loadManifest(root) {
+    return parseManifest(await readFile(join(root, 'manifest.yaml'), 'utf8'));
+}
+export async function saveManifest(root, m) {
+    await mkdir(root, { recursive: true });
+    await writeFile(join(root, 'manifest.yaml'), serializeManifest(m), 'utf8');
+    try {
+        await exec('git', ['-C', root, 'rev-parse', '--git-dir']);
+        await exec('git', ['-C', root, 'add', '-A']);
+        await exec('git', ['-C', root, 'commit', '-m', 'ccprofiles: update manifest']);
+    }
+    catch { /* not a repo or nothing to commit — fine */ }
+}

package/dist/platform.d.ts

@@ -0,0 +1,13 @@
+export type OsKind = 'darwin' | 'linux' | 'win32';
+export interface Platform {
+    os: OsKind;
+    home: string;
+    rcFile: string;
+}
+export declare function detectPlatform(opts?: {
+    osKind?: OsKind;
+    home?: string;
+    shell?: string;
+}): Platform;
+export declare function renderPath(template: string, p: Platform): string;
+export declare function toTemplate(absPath: string, p: Platform): string;

package/dist/platform.js

@@ -0,0 +1,20 @@
+import os from 'node:os';
+import path from 'node:path';
+export function detectPlatform(opts = {}) {
+    const osKind = opts.osKind ?? process.platform;
+    const home = opts.home ?? os.homedir();
+    const shell = opts.shell ?? process.env.SHELL ?? '';
+    const rcFile = osKind === 'win32'
+        ? path.win32.join(home, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1')
+        : path.posix.join(home, shell.endsWith('zsh') ? '.zshrc' : '.bashrc');
+    return { os: osKind, home, rcFile };
+}
+export function renderPath(template, p) {
+    const raw = template.replaceAll('{home}', p.home);
+    return p.os === 'win32' ? raw.replaceAll('/', '\\') : raw;
+}
+export function toTemplate(absPath, p) {
+    const norm = absPath.replaceAll('\\', '/');
+    const home = p.home.replaceAll('\\', '/');
+    return norm.startsWith(home) ? '{home}' + norm.slice(home.length) : norm;
+}

package/dist/rcblock.d.ts

@@ -0,0 +1,6 @@
+import type { Manifest } from './manifest.js';
+import type { Platform } from './platform.js';
+export declare const BEGIN_MARK = "# >>> ccprofiles managed >>>";
+export declare const END_MARK = "# <<< ccprofiles managed <<<";
+export declare function renderRcBlock(m: Manifest, p: Platform): string;
+export declare function upsertManagedBlock(content: string, block: string): string;

package/dist/rcblock.js

@@ -0,0 +1,52 @@
+export const BEGIN_MARK = '# >>> ccprofiles managed >>>';
+export const END_MARK = '# <<< ccprofiles managed <<<';
+const SECRET_PREFIX = 'secret://';
+// Defense in depth: manifest validation already rejects shell metacharacters in
+// identifiers, but free-form env *values* are still escaped for their quoted context.
+function escapePosix(v) {
+    return v.replace(/(["\\$`])/g, '\\$1'); // inside "..." — escape " \ $ `
+}
+function escapePwsh(v) {
+    return v.replace(/`/g, '``').replace(/"/g, '`"').replace(/\$/g, '`$'); // inside "..." — ` is PS escape
+}
+function homeVar(p) {
+    return p.os === 'win32' ? '$env:USERPROFILE' : '$HOME';
+}
+function profileDirExpr(pr, p) {
+    const suffix = pr.dir.replace('{home}', '');
+    return p.os === 'win32' ? homeVar(p) + suffix.replaceAll('/', '\\') : homeVar(p) + suffix;
+}
+function renderPosix(pr, p) {
+    const lines = [`${pr.launcher}() {`];
+    for (const [k, v] of Object.entries(pr.env)) {
+        lines.push(v.startsWith(SECRET_PREFIX)
+            ? `  export ${k}="$(ccp secrets get ${v.slice(SECRET_PREFIX.length)})"`
+            : `  export ${k}="${escapePosix(v)}"`);
+    }
+    lines.push(`  CLAUDE_CONFIG_DIR="${profileDirExpr(pr, p)}" claude "$@"`, '}');
+    return lines.join('\n');
+}
+function renderPwsh(pr, p) {
+    const lines = [`function ${pr.launcher} {`];
+    for (const [k, v] of Object.entries(pr.env)) {
+        lines.push(v.startsWith(SECRET_PREFIX)
+            ? `  $env:${k} = (ccp secrets get ${v.slice(SECRET_PREFIX.length)})`
+            : `  $env:${k} = "${escapePwsh(v)}"`);
+    }
+    lines.push(`  $env:CLAUDE_CONFIG_DIR = "${profileDirExpr(pr, p)}"`, '  claude @args', '}');
+    return lines.join('\n');
+}
+export function renderRcBlock(m, p) {
+    const fns = m.profiles
+        .filter(pr => pr.launcher)
+        .map(pr => (p.os === 'win32' ? renderPwsh(pr, p) : renderPosix(pr, p)));
+    return [BEGIN_MARK, ...fns, END_MARK].join('\n');
+}
+export function upsertManagedBlock(content, block) {
+    const start = content.indexOf(BEGIN_MARK);
+    const end = content.indexOf(END_MARK);
+    if (start !== -1 && end !== -1 && end > start) {
+        return content.slice(0, start) + block + content.slice(end + END_MARK.length);
+    }
+    return content.trimEnd() + (content.trim() ? '\n\n' : '') + block + '\n';
+}

package/dist/secrets.d.ts

@@ -0,0 +1,54 @@
+import type { Platform } from './platform.js';
+export interface SecretsBackend {
+    readonly name: string;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export declare class FileBackend implements SecretsBackend {
+    private filePath;
+    private passphrase;
+    readonly name = "encrypted-file";
+    constructor(filePath: string, passphrase: string);
+    private load;
+    private key;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+type ExecFn = (cmd: string, args: string[]) => Promise<{
+    stdout: string;
+}>;
+export declare class KeychainBackend implements SecretsBackend {
+    private exec;
+    readonly name = "macos-keychain";
+    constructor(exec?: ExecFn);
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    delete(key: string): Promise<void>;
+}
+export declare class SecretToolBackend implements SecretsBackend {
+    private exec;
+    readonly name = "libsecret";
+    constructor(exec?: ExecFn);
+    set(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    delete(key: string): Promise<void>;
+}
+export declare class SecretsStore {
+    private backend;
+    private indexPath;
+    constructor(backend: SecretsBackend, indexPath: string);
+    private readIndex;
+    private writeIndex;
+    get backendName(): string;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(): Promise<string[]>;
+}
+export declare function defaultBackend(p: Platform, opts: {
+    filePath: string;
+    passphrase?: () => Promise<string>;
+}): Promise<SecretsBackend>;
+export {};

package/dist/secrets.js

@@ -0,0 +1,144 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { atomicWrite } from './fsutil.js';
+export class FileBackend {
+    filePath;
+    passphrase;
+    name = 'encrypted-file';
+    constructor(filePath, passphrase) {
+        this.filePath = filePath;
+        this.passphrase = passphrase;
+    }
+    async load() {
+        if (!existsSync(this.filePath))
+            return { salt: randomBytes(16).toString('base64'), entries: {} };
+        return JSON.parse(await readFile(this.filePath, 'utf8'));
+    }
+    key(salt) {
+        return scryptSync(this.passphrase, Buffer.from(salt, 'base64'), 32);
+    }
+    async get(key) {
+        const f = await this.load();
+        const e = f.entries[key];
+        if (!e)
+            return null;
+        const d = createDecipheriv('aes-256-gcm', this.key(f.salt), Buffer.from(e.iv, 'base64'));
+        d.setAuthTag(Buffer.from(e.tag, 'base64'));
+        return d.update(Buffer.from(e.data, 'base64')).toString('utf8') + d.final('utf8'); // throws on bad passphrase
+    }
+    async set(key, value) {
+        const f = await this.load();
+        const iv = randomBytes(12);
+        const c = createCipheriv('aes-256-gcm', this.key(f.salt), iv);
+        const data = Buffer.concat([c.update(value, 'utf8'), c.final()]);
+        f.entries[key] = { iv: iv.toString('base64'), tag: c.getAuthTag().toString('base64'), data: data.toString('base64') };
+        await atomicWrite(this.filePath, JSON.stringify(f));
+    }
+    async delete(key) {
+        const f = await this.load();
+        delete f.entries[key];
+        await atomicWrite(this.filePath, JSON.stringify(f));
+    }
+}
+const realExec = promisify(execFile);
+export class KeychainBackend {
+    exec;
+    name = 'macos-keychain';
+    constructor(exec = realExec) {
+        this.exec = exec;
+    }
+    async set(key, value) {
+        await this.exec('security', ['add-generic-password', '-U', '-s', 'ccprofiles', '-a', key, '-w', value]);
+    }
+    async get(key) {
+        try {
+            const { stdout } = await this.exec('security', ['find-generic-password', '-s', 'ccprofiles', '-a', key, '-w']);
+            return stdout.replace(/\n$/, '');
+        }
+        catch {
+            return null;
+        }
+    }
+    async delete(key) {
+        try {
+            await this.exec('security', ['delete-generic-password', '-s', 'ccprofiles', '-a', key]);
+        }
+        catch { /* absent */ }
+    }
+}
+export class SecretToolBackend {
+    exec;
+    name = 'libsecret';
+    constructor(exec = realExec) {
+        this.exec = exec;
+    }
+    async set(key, value) {
+        const child = await import('node:child_process');
+        await new Promise((resolve, reject) => {
+            const proc = child.spawn('secret-tool', ['store', '--label=ccprofiles', 'service', 'ccprofiles', 'key', key], { stdio: ['pipe', 'ignore', 'ignore'] });
+            proc.on('error', reject);
+            proc.on('close', code => (code === 0 ? resolve() : reject(new Error(`secret-tool exited ${code}`))));
+            proc.stdin.end(value);
+        });
+    }
+    async get(key) {
+        try {
+            const { stdout } = await this.exec('secret-tool', ['lookup', 'service', 'ccprofiles', 'key', key]);
+            return stdout;
+        }
+        catch {
+            return null;
+        }
+    }
+    async delete(key) {
+        try {
+            await this.exec('secret-tool', ['clear', 'service', 'ccprofiles', 'key', key]);
+        }
+        catch { /* absent */ }
+    }
+}
+export class SecretsStore {
+    backend;
+    indexPath;
+    constructor(backend, indexPath) {
+        this.backend = backend;
+        this.indexPath = indexPath;
+    }
+    async readIndex() {
+        if (!existsSync(this.indexPath))
+            return [];
+        return JSON.parse(await readFile(this.indexPath, 'utf8'));
+    }
+    async writeIndex(names) {
+        await atomicWrite(this.indexPath, JSON.stringify([...new Set(names)].sort()));
+    }
+    get backendName() { return this.backend.name; }
+    async get(key) { return this.backend.get(key); }
+    async set(key, value) {
+        await this.backend.set(key, value);
+        await this.writeIndex([...(await this.readIndex()), key]);
+    }
+    async delete(key) {
+        await this.backend.delete(key);
+        await this.writeIndex((await this.readIndex()).filter(n => n !== key));
+    }
+    async list() { return this.readIndex(); }
+}
+export async function defaultBackend(p, opts) {
+    if (p.os === 'darwin')
+        return new KeychainBackend();
+    if (p.os === 'linux') {
+        try {
+            await realExec('secret-tool', ['--help']);
+            return new SecretToolBackend();
+        }
+        catch { /* fall through */ }
+    }
+    const pw = opts.passphrase ? await opts.passphrase() : '';
+    if (!pw)
+        throw new Error('encrypted-file backend requires a passphrase');
+    return new FileBackend(opts.filePath, pw);
+}

package/dist/syncclient.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceEntry } from './devices.js';
+/** PIN-authenticated ECDH pairing. Throws if the server can't prove it knows the PIN. */
+export declare function pairWithServer(host: string, port: number, pin: string, name: string): Promise<DeviceEntry>;
+export declare function fetchRemote(device: DeviceEntry): Promise<{
+    manifestYaml: string;
+    assets: Record<string, string>;
+}>;
+export declare function fetchSecrets(device: DeviceEntry, names: string[]): Promise<Record<string, string>>;

package/dist/syncclient.js

@@ -0,0 +1,37 @@
+import { deriveSharedKey, handshakeKeys, openJson, pinMac, sealJson } from './crypto.js';
+async function post(host, port, path, payload) {
+    let res;
+    try {
+        res = await fetch(`http://${host}:${port}${path}`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+    }
+    catch {
+        throw new Error(`cannot reach ${host}:${port} — is \`ccp serve\` running on the other device?`);
+    }
+    const data = await res.json();
+    if (!res.ok)
+        throw new Error(`${path}: ${data.error ?? res.status}`);
+    return data;
+}
+/** PIN-authenticated ECDH pairing. Throws if the server can't prove it knows the PIN. */
+export async function pairWithServer(host, port, pin, name) {
+    const { privateKey, publicRaw } = handshakeKeys();
+    const { handshakeId, serverPub, salt } = await post(host, port, '/pair', { clientPub: publicRaw });
+    const key = deriveSharedKey(privateKey, serverPub, salt);
+    const { mac, token } = await post(host, port, '/pair/confirm', { handshakeId, mac: pinMac(key, 'client', pin), name });
+    if (mac !== pinMac(key, 'server', pin))
+        throw new Error('server failed PIN verification — possible MITM, aborting');
+    return { name, host, port, token, key: key.toString('base64') };
+}
+export async function fetchRemote(device) {
+    const { sealed } = await post(device.host, device.port, '/manifest', { token: device.token });
+    return openJson(Buffer.from(device.key, 'base64'), sealed);
+}
+export async function fetchSecrets(device, names) {
+    const key = Buffer.from(device.key, 'base64');
+    const { sealed } = await post(device.host, device.port, '/secrets', { token: device.token, sealed: sealJson(key, { names }) });
+    return openJson(key, sealed);
+}

package/dist/syncserver.d.ts

@@ -0,0 +1,21 @@
+import type { Platform } from './platform.js';
+/** After this many failed PIN confirmations the server refuses further pairing (brute-force guard). */
+export declare const MAX_PIN_ATTEMPTS = 5;
+export interface SyncServerDeps {
+    manifestRoot: string;
+    platform: Platform;
+    allowSecrets?: boolean;
+    /** resolve secret values by name (from the local store) when --allow-secrets */
+    secretValues?: (names: string[]) => Promise<Record<string, string>>;
+    port?: number;
+    /** interface to bind (default 0.0.0.0 — all interfaces, needed for LAN peers) */
+    host?: string;
+    /** override the generated PIN (tests) */
+    pin?: string;
+}
+export declare function startSyncServer(deps: SyncServerDeps): Promise<{
+    port: number;
+    host: string;
+    pin: string;
+    close: () => Promise<void>;
+}>;

package/dist/syncserver.js

@@ -0,0 +1,112 @@
+import { createServer } from 'node:http';
+import { timingSafeEqual } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { deriveSharedKey, handshakeKeys, newPin, newSalt, newToken, openJson, pinMac, sealJson, } from './crypto.js';
+import { parseManifest } from './manifest.js';
+import { collectAssets } from './assets.js';
+import { loadDevices, saveDevices } from './devices.js';
+/** After this many failed PIN confirmations the server refuses further pairing (brute-force guard). */
+export const MAX_PIN_ATTEMPTS = 5;
+async function body(req) {
+    const chunks = [];
+    for await (const c of req)
+        chunks.push(c);
+    return chunks.length ? JSON.parse(Buffer.concat(chunks).toString('utf8')) : {};
+}
+function send(res, code, obj) {
+    res.writeHead(code, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(obj));
+}
+/** Constant-time base64 comparison; false on length mismatch (never throws). */
+function ctEqual(a, b) {
+    const ba = Buffer.from(String(a ?? ''), 'base64');
+    const bb = Buffer.from(String(b ?? ''), 'base64');
+    return ba.length === bb.length && ba.length > 0 && timingSafeEqual(ba, bb);
+}
+/** Constant-time comparison of the opaque device tokens (base64url strings). */
+function ctEqualToken(a, b) {
+    const ba = Buffer.from(String(a ?? ''), 'utf8');
+    const bb = Buffer.from(String(b ?? ''), 'utf8');
+    return ba.length === bb.length && ba.length > 0 && timingSafeEqual(ba, bb);
+}
+export async function startSyncServer(deps) {
+    const pin = deps.pin ?? newPin();
+    const host = deps.host ?? '0.0.0.0';
+    // per-handshake state keyed by a server-issued id — no shared global, no cross-client clobber
+    const handshakes = new Map();
+    let failedAttempts = 0;
+    let locked = false;
+    const server = createServer(async (req, res) => {
+        try {
+            if (req.method !== 'POST')
+                return send(res, 405, { error: 'POST only' });
+            const payload = await body(req).catch(() => null);
+            if (payload === null)
+                return send(res, 400, { error: 'invalid request body' });
+            if (req.url === '/pair') {
+                if (locked)
+                    return send(res, 429, { error: 'pairing locked after too many failed attempts — restart ccp serve' });
+                const { privateKey, publicRaw } = handshakeKeys();
+                const salt = newSalt();
+                const key = deriveSharedKey(privateKey, payload.clientPub, salt);
+                const handshakeId = newToken();
+                handshakes.set(handshakeId, { privateKey, salt, key });
+                return send(res, 200, { handshakeId, serverPub: publicRaw, salt });
+            }
+            if (req.url === '/pair/confirm') {
+                if (locked)
+                    return send(res, 429, { error: 'pairing locked after too many failed attempts — restart ccp serve' });
+                const pending = typeof payload.handshakeId === 'string' ? handshakes.get(payload.handshakeId) : undefined;
+                if (!pending)
+                    return send(res, 400, { error: 'no pending handshake (call /pair first)' });
+                handshakes.delete(payload.handshakeId); // one shot per handshake
+                if (!ctEqual(payload.mac, pinMac(pending.key, 'client', pin))) {
+                    if (++failedAttempts >= MAX_PIN_ATTEMPTS)
+                        locked = true;
+                    return send(res, 403, { error: 'pin mismatch', attemptsLeft: Math.max(0, MAX_PIN_ATTEMPTS - failedAttempts) });
+                }
+                failedAttempts = 0; // successful pair resets the counter
+                const token = newToken();
+                const devices = await loadDevices(deps.manifestRoot);
+                devices.push({ name: String(payload.name ?? 'peer'), host: '-', port: 0, token, key: pending.key.toString('base64') });
+                await saveDevices(deps.manifestRoot, devices);
+                return send(res, 200, { mac: pinMac(pending.key, 'server', pin), token });
+            }
+            // authenticated endpoints: match device by constant-time token compare
+            const devices = await loadDevices(deps.manifestRoot);
+            const device = typeof payload.token === 'string'
+                ? devices.find(d => ctEqualToken(d.token, payload.token))
+                : undefined;
+            if (!device)
+                return send(res, 401, { error: 'unknown token' });
+            const key = Buffer.from(device.key, 'base64');
+            if (req.url === '/manifest') {
+                const manifestYaml = await readFile(join(deps.manifestRoot, 'manifest.yaml'), 'utf8');
+                const assets = await collectAssets(parseManifest(manifestYaml), deps.platform);
+                return send(res, 200, { sealed: sealJson(key, { manifestYaml, assets }) });
+            }
+            if (req.url === '/secrets') {
+                if (!deps.allowSecrets || !deps.secretValues)
+                    return send(res, 403, { error: 'secrets transfer not enabled (serve --allow-secrets)' });
+                const names = payload.sealed ? openJson(key, payload.sealed).names : [];
+                const values = await deps.secretValues(names);
+                return send(res, 200, { sealed: sealJson(key, values) });
+            }
+            return send(res, 404, { error: 'not found' });
+        }
+        catch {
+            // never leak internal error detail (paths, parse internals) to callers
+            return send(res, 500, { error: 'internal error' });
+        }
+    });
+    await new Promise(resolve => server.listen(deps.port ?? 0, host, resolve));
+    const address = server.address();
+    const port = typeof address === 'object' && address ? address.port : 0;
+    return {
+        port,
+        host,
+        pin,
+        close: () => new Promise((resolve, reject) => server.close(e => (e ? reject(e) : resolve()))),
+    };
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "ccprofiles-core",
+  "version": "0.1.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",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "license": "MIT",
+  "repository": { "type": "git", "url": "git+https://github.com/tmfadhlul/claude-code-profile.git", "directory": "packages/core" },
+  "homepage": "https://github.com/tmfadhlul/claude-code-profile#readme",
+  "bugs": "https://github.com/tmfadhlul/claude-code-profile/issues",
+  "keywords": ["claude-code", "claude", "profiles", "mcp", "config-management"],
+  "engines": { "node": ">=20" },
+  "dependencies": { "yaml": "^2.5.0", "zod": "^3.23.0" }
+}