@agentage/cli 0.39.0 → 0.40.0

package/dist/core/loader/secrets.d.ts

@@ -0,0 +1,9 @@
+import { type ExtensionSecrets } from '../../extension.js';
+import { type DiscoveredExtension } from './discover.js';
+export interface SecretKey {
+    id: string;
+    key: string;
+    description: string | null;
+}
+export declare const secretsFor: (id: string) => ExtensionSecrets;
+export declare const missingSecrets: (extensions: DiscoveredExtension[]) => SecretKey[];

package/dist/core/loader/secrets.js

@@ -0,0 +1,28 @@
+import {} from '../../extension.js';
+import { withFileLock } from '../../lib/fs/file-lock.js';
+import { isRecord, readJson, writeJsonAtomic } from '../../lib/fs/json-file.js';
+import { secretsPath } from '../paths.js';
+import {} from './discover.js';
+const isStrings = (value) => isRecord(value) && Object.values(value).every((v) => typeof v === 'string');
+const isSecretsFile = (value) => isRecord(value) && Object.values(value).every(isStrings);
+const readSecrets = () => readJson(secretsPath(), isSecretsFile) ?? {};
+// Re-read under the lock, so two processes never drop each other's secret.
+const change = (id, fn) => withFileLock(secretsPath(), () => {
+    const all = readSecrets();
+    writeJsonAtomic(secretsPath(), { ...all, [id]: fn(all[id] ?? {}) });
+});
+export const secretsFor = (id) => ({
+    get: async (key) => readSecrets()[id]?.[key],
+    set: (key, value) => change(id, (own) => ({ ...own, [key]: value })),
+    delete: (key) => change(id, (own) => Object.fromEntries(Object.entries(own).filter(([k]) => k !== key))),
+});
+// The keys extensions declare `secret: true` that this machine has no value for yet.
+export const missingSecrets = (extensions) => {
+    const stored = readSecrets();
+    return extensions.flatMap((ext) => {
+        const id = ext.id ?? '';
+        return ext.secrets
+            .filter((key) => stored[id]?.[key] === undefined)
+            .map((key) => ({ id, key, description: ext.descriptions[key] ?? null }));
+    });
+};

package/dist/core/loader/state.d.ts

@@ -5,8 +5,8 @@ export interface RunState {
     pid: number;
     state: RunStateName;
     error: string | null;
+    version: string | null;
+    lastOk: string | null;
 }
-export interface RunStateDeps {
-    dir: () => string;
-}
-export declare const readRunState: (id: string, deps?: RunStateDeps) => RunState | null;
+export declare const readRunState: (id: string) => RunState | null;
+export declare const writeRunState: (id: string, run: Pick<RunState, "state" | "error" | "version">) => void;

package/dist/core/loader/state.js

@@ -1,21 +1,31 @@
+import { mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { isRecord, readJson } from '../../lib/fs/json-file.js';
+import { isRecord, readJson, writeJsonAtomic } from '../../lib/fs/json-file.js';
 import { stateDir } from '../paths.js';
 import { ID_PATTERN } from './manifest.js';
 export const RUN_STATES = ['ok', 'failed', 'invalid', 'off', 'blocked', 'installed'];
-const defaultDeps = { dir: stateDir };
 const isRunStateName = (value) => RUN_STATES.some((name) => name === value);
+// Absent in files written before the field existed.
+const optionalText = (value) => value === undefined || value === null || typeof value === 'string';
 const isRunState = (value) => isRecord(value) &&
     typeof value['at'] === 'string' &&
     typeof value['pid'] === 'number' &&
     isRunStateName(value['state']) &&
-    (value['error'] === undefined || value['error'] === null || typeof value['error'] === 'string');
-// Reads the core's own record of the last run; plugin logs are never consulted.
-export const readRunState = (id, deps = defaultDeps) => {
+    ['error', 'version', 'lastOk'].every((key) => optionalText(value[key]));
+// Reads the core's own record of the last run; extension logs are never consulted.
+export const readRunState = (id) => {
     if (!ID_PATTERN.test(id))
         return null;
-    const found = readJson(join(deps.dir(), `${id}.json`), isRunState);
+    const found = readJson(join(stateDir(), `${id}.json`), isRunState);
     if (!found)
         return null;
-    return { at: found.at, pid: found.pid, state: found.state, error: found.error ?? null };
+    const { at, pid, state, error = null, version = null, lastOk = null } = found;
+    return { at, pid, state, error, version, lastOk };
+};
+// Written by the core after each load attempt; a failed one keeps the last ok version.
+export const writeRunState = (id, run) => {
+    const lastOk = run.state === 'ok' ? run.version : (readRunState(id)?.lastOk ?? null);
+    mkdirSync(stateDir(), { recursive: true, mode: 0o700 });
+    const state = { at: new Date().toISOString(), pid: process.pid, ...run, lastOk };
+    writeJsonAtomic(join(stateDir(), `${id}.json`), state);
 };

package/dist/core/loader/states.d.ts

@@ -1,7 +1,7 @@
-import { type DiscoveredPlugin } from './discover.js';
+import { type DiscoveredExtension } from './discover.js';
 export type StaticState = 'installed' | 'off' | 'blocked' | 'invalid' | 'missing';
 export interface StaticResult {
     state: StaticState;
     error: string | null;
 }
-export declare const staticStates: (plugins: DiscoveredPlugin[], off: string[]) => Map<string, StaticResult>;
+export declare const staticStates: (extensions: DiscoveredExtension[], off: string[]) => Map<string, StaticResult>;

package/dist/core/loader/states.js

@@ -41,12 +41,12 @@ const resolveState = (p, walk) => {
     walk.done.set(p.pkg, result);
     return result;
 };
-// The states `status` can know without running plugin code; `ok` and `failed` need a load.
-export const staticStates = (plugins, off) => {
-    const byPkg = new Map(plugins.map((p) => [p.pkg, p]));
-    const own = new Map(plugins.map((p) => [p.pkg, ownState(p, off, byPkg)]));
+// The states `status` can know without running extension code; `ok` and `failed` need a load.
+export const staticStates = (extensions, off) => {
+    const byPkg = new Map(extensions.map((p) => [p.pkg, p]));
+    const own = new Map(extensions.map((p) => [p.pkg, ownState(p, off, byPkg)]));
     const walk = { byPkg, own, done: new Map() };
-    for (const p of plugins)
+    for (const p of extensions)
         resolveState(p, walk);
     return walk.done;
 };

package/dist/core/loader/timeout.d.ts

@@ -0,0 +1 @@
+export declare const withTimeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;

package/dist/core/loader/timeout.js

@@ -0,0 +1,8 @@
+// The timer is always cleared; the promise given up on runs on, as loaded code cannot be stopped.
+export const withTimeout = (promise, ms) => {
+    let timer;
+    const deadline = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error('timeout')), ms);
+    });
+    return Promise.race([promise, deadline]).finally(() => clearTimeout(timer));
+};

package/dist/core/loader/use.d.ts

@@ -0,0 +1,8 @@
+import { type ExtensionApi, type ExtensionUse } from '../../extension.js';
+import { type DiscoveredExtension } from './discover.js';
+export interface LoadedPeer {
+    ext: DiscoveredExtension;
+    facade: ExtensionApi;
+}
+export declare const facadeOf: (api: unknown) => ExtensionApi;
+export declare const createUse: (self: DiscoveredExtension, loaded: ReadonlyMap<string, LoadedPeer>) => ExtensionUse;

package/dist/core/loader/use.js

@@ -0,0 +1,18 @@
+import {} from '../../extension.js';
+import { isRecord } from '../../lib/fs/json-file.js';
+import {} from './discover.js';
+// Only own function members cross, bound to the original, in a frozen object of their own.
+export const facadeOf = (api) => {
+    const methods = Object.entries(isRecord(api) ? api : {}).filter((entry) => typeof entry[1] === 'function');
+    return Object.freeze(Object.fromEntries(methods.map(([name, fn]) => [name, fn.bind(api)])));
+};
+// `loaded` is keyed by id; only an extension `self` peer-depends on is reachable.
+export const createUse = (self, loaded) => ((id, options = {}) => {
+    const peer = loaded.get(id);
+    const peers = [...self.peers, ...self.optionalPeers];
+    if (peer && peers.includes(peer.ext.pkg))
+        return peer.facade;
+    if (options.optional)
+        return undefined;
+    throw new Error(`use("${id}"): not a loaded peer of ${self.id}`);
+});

package/dist/core/paths.d.ts

@@ -1,4 +1,8 @@
 export declare const profilePath: () => string;
 export declare const machinePath: () => string;
 export declare const stateDir: () => string;
-export declare const pluginsDir: () => string;
+export declare const extensionsDir: () => string;
+export declare const secretsPath: () => string;
+export declare const dataDir: (id: string) => string;
+export declare const cacheDir: (id: string) => string;
+export declare const logsDir: () => string;

package/dist/core/paths.js

@@ -3,4 +3,8 @@ import { getConfigDir } from '../lib/fs/config.js';
 export const profilePath = () => join(getConfigDir(), 'profile.json');
 export const machinePath = () => join(getConfigDir(), 'machine.json');
 export const stateDir = () => join(getConfigDir(), 'state');
-export const pluginsDir = () => process.env['AGENTAGE_PLUGINS_DIR'] || join(getConfigDir(), 'plugins');
+export const extensionsDir = () => process.env['AGENTAGE_EXTENSIONS_DIR'] || join(getConfigDir(), 'extensions');
+export const secretsPath = () => join(getConfigDir(), 'secrets.json');
+export const dataDir = (id) => join(getConfigDir(), 'data', id);
+export const cacheDir = (id) => join(getConfigDir(), 'cache', id);
+export const logsDir = () => join(getConfigDir(), 'logs');

package/dist/core/profile/cloud.d.ts

@@ -0,0 +1,53 @@
+import { type Profile } from './schema.js';
+export declare const PROFILE_PATH = "/v1/profile";
+export type JsonObject = Record<string, unknown>;
+export interface CloudInit {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    timeoutMs?: number;
+}
+export type CloudFetch = (path: string, init?: CloudInit) => Promise<Response>;
+export interface Account {
+    fetch: CloudFetch;
+    id: () => Promise<string | null>;
+}
+export interface ProfileWrite {
+    version: number;
+    profile: JsonObject;
+    lock: JsonObject | null;
+    npmMajor: number | null;
+}
+export interface CloudProfile {
+    profile: Profile;
+    readOnly: boolean;
+    lock: JsonObject | null;
+    npmMajor: number | null;
+    etag: string | null;
+}
+export type Pull = {
+    kind: 'current';
+} | {
+    kind: 'found';
+    doc: CloudProfile & {
+        etag: string;
+    };
+} | {
+    kind: 'none';
+} | {
+    kind: 'unavailable';
+    reason: string;
+};
+export type Push = {
+    kind: 'stored';
+    etag: string;
+} | {
+    kind: 'conflict';
+    current: CloudProfile | null;
+};
+export declare class NotPushedError extends Error {
+}
+export declare const localProfile: (profile: Profile) => CloudProfile;
+export declare const errorCode: (res: Response) => Promise<string | null>;
+export declare const pullProfile: (fetch: CloudFetch, etag: string | null, timeoutMs?: number) => Promise<Pull>;
+export declare const pushProfile: (fetch: CloudFetch, body: ProfileWrite, etag: string | null) => Promise<Push>;

package/dist/core/profile/cloud.js

@@ -0,0 +1,109 @@
+import { isRecord } from '../../lib/fs/json-file.js';
+import { parseProfile } from './schema.js';
+// One resource per account: the profile, npm's lock and the npm major that wrote it, one ETag.
+export const PROFILE_PATH = '/v1/profile';
+// The account answered a push with something other than a new ETag or a 412.
+export class NotPushedError extends Error {
+}
+// A profile that is not in the account yet: pushing it creates it.
+export const localProfile = (profile) => ({
+    profile,
+    readOnly: profile.version > 1,
+    lock: null,
+    npmMajor: null,
+    etag: null,
+});
+// What a request ended with: the Response, or why there was none.
+const attempt = async (request) => {
+    try {
+        return await request();
+    }
+    catch (err) {
+        return err.name === 'TimeoutError' ? 'timed out' : err.message;
+    }
+};
+const bodyOf = async (res) => {
+    try {
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+};
+// The code of the house error envelope, e.g. PROFILE_NOT_FOUND; null without one. Reads the body.
+export const errorCode = async (res) => {
+    const body = await bodyOf(res);
+    const error = isRecord(body) && isRecord(body['error']) ? body['error'] : {};
+    return typeof error['code'] === 'string' ? error['code'] : null;
+};
+// e.g. "503 AUTH_UNAVAILABLE": the status, and the envelope's code when there is one.
+const failureOf = async (res) => {
+    const code = await errorCode(res);
+    return code === null ? `${res.status}` : `${res.status} ${code}`;
+};
+const isMajor = (value) => value === null || (typeof value === 'number' && Number.isInteger(value));
+// A served resource and its etag, parsed; a string says what is wrong with it.
+const resourceOf = (data, etag) => {
+    if (!isRecord(data) || typeof etag !== 'string')
+        return 'unexpected answer';
+    const { lock, npmMajor } = data;
+    if (!(lock === null || isRecord(lock)) || !isMajor(npmMajor))
+        return 'unexpected answer';
+    const parsed = parseProfile(data['profile']);
+    if (!parsed.ok)
+        return `the profile in your account is invalid: ${parsed.errors.join('; ')}`;
+    return { profile: parsed.profile, readOnly: parsed.readOnly, lock, npmMajor, etag };
+};
+// meta.etag equals the ETag header on a 2xx; either will do.
+const etagOf = (body, header) => {
+    const meta = isRecord(body) && isRecord(body['meta']) ? body['meta'] : {};
+    return meta['etag'] ?? header;
+};
+const served = (body, header) => resourceOf(isRecord(body) ? body['data'] : null, etagOf(body, header));
+const unavailable = (reason) => ({ kind: 'unavailable', reason });
+const NO_PROFILE = '404 PROFILE_NOT_FOUND';
+// GET, conditional on the local copy's etag: 304 keeps it, 200 replaces it, 404 means none yet.
+export const pullProfile = async (fetch, etag, timeoutMs) => {
+    const headers = etag === null ? {} : { 'if-none-match': etag };
+    const res = await attempt(() => fetch(PROFILE_PATH, { headers, timeoutMs }));
+    if (typeof res === 'string')
+        return unavailable(res);
+    if (res.status === 304)
+        return { kind: 'current' };
+    if (res.status !== 200) {
+        // Any other 404 is an API without the profile route, not an account without a profile.
+        const failure = await failureOf(res);
+        return failure === NO_PROFILE ? { kind: 'none' } : unavailable(failure);
+    }
+    const doc = served(await bodyOf(res), res.headers.get('etag'));
+    return typeof doc === 'string' ? unavailable(doc) : { kind: 'found', doc };
+};
+// A 412 carries the account's current resource and etag (both null when it holds none).
+const conflictOf = (body) => {
+    const error = isRecord(body) && isRecord(body['error']) ? body['error'] : {};
+    const details = isRecord(error['details']) ? error['details'] : {};
+    if (details['current'] === null)
+        return { kind: 'conflict', current: null };
+    const current = resourceOf(details['current'], details['etag']);
+    if (typeof current === 'string')
+        throw new NotPushedError(`not pushed to your account (412: ${current})`);
+    return { kind: 'conflict', current };
+};
+const notPushed = (reason) => new NotPushedError(`not pushed to your account (${reason})`);
+// PUT the whole resource: If-Match replaces the copy it was pulled at, no etag creates it.
+export const pushProfile = async (fetch, body, etag) => {
+    const precondition = etag === null ? { 'if-none-match': '*' } : { 'if-match': etag };
+    const headers = { 'content-type': 'application/json', ...precondition };
+    const init = { method: 'PUT', headers, body: JSON.stringify(body) };
+    const res = await attempt(() => fetch(PROFILE_PATH, init));
+    if (typeof res === 'string')
+        throw notPushed(res);
+    if (res.status === 412)
+        return conflictOf(await bodyOf(res));
+    if (res.status !== 200 && res.status !== 201)
+        throw notPushed(await failureOf(res));
+    const stored = etagOf(await bodyOf(res), res.headers.get('etag'));
+    if (typeof stored !== 'string')
+        throw notPushed('unexpected answer');
+    return { kind: 'stored', etag: stored };
+};

package/dist/core/profile/edit.d.ts

@@ -0,0 +1,4 @@
+import { type Profile } from './schema.js';
+export declare const addExtension: (profile: Profile, name: string, spec: string, machineId: string, off: boolean) => Profile;
+export declare const dropExtension: (profile: Profile, name: string, machineId: string) => Profile;
+export declare const changeProfile: (change: (profile: Profile) => Profile) => Promise<Profile>;

package/dist/core/profile/edit.js

@@ -0,0 +1,27 @@
+import { loadMachine, setProfileSource } from './machine.js';
+import { editableProfile, mutateProfile } from './profile.js';
+import {} from './schema.js';
+const NO_ENTRY = { off: [], config: {}, extra: {} };
+// This machine's off list with `name` in or out; an entry is only created to turn one off.
+const withOff = (profile, machineId, name, off) => {
+    const self = profile.machines[machineId];
+    if (!self && !off)
+        return profile;
+    const rest = (self?.off ?? []).filter((pkg) => pkg !== name);
+    const entry = { ...NO_ENTRY, ...self, off: off ? [...rest, name] : rest };
+    return { ...profile, machines: { ...profile.machines, [machineId]: entry } };
+};
+// Installing a name again replaces its spec; without --off it loads on this machine again.
+export const addExtension = (profile, name, spec, machineId, off) => withOff({ ...profile, extensions: { ...profile.extensions, [name]: spec } }, machineId, name, off);
+// Other machines' off lists are theirs to keep.
+export const dropExtension = (profile, name, machineId) => {
+    const extensions = Object.fromEntries(Object.entries(profile.extensions).filter(([pkg]) => pkg !== name));
+    return withOff({ ...profile, extensions }, machineId, name, false);
+};
+// A file source stays `file`; any other profile changed here is now this machine's own copy.
+export const changeProfile = async (change) => {
+    const next = await mutateProfile(() => change(editableProfile()));
+    if ((await loadMachine()).profileSource !== 'file')
+        await setProfileSource('default');
+    return next;
+};

package/dist/core/profile/machine.d.ts

@@ -4,15 +4,15 @@ export interface MachineFile {
     name: string;
     dev: Record<string, string>;
     profileSource: ProfileSource;
+    accountId: string | null;
+    profileEtag: string | null;
 }
-export interface MachineDeps {
-    path: () => string;
-    read: (path: string) => unknown;
-    write: (path: string, machine: MachineFile) => void;
-    lock: <T>(path: string, fn: () => T) => Promise<T>;
-    hostname: () => string;
-    newId: () => string;
-}
-export declare const MACHINE_ID: RegExp;
-export declare const parseMachine: (raw: unknown) => MachineFile | null;
-export declare const loadMachine: (deps?: MachineDeps) => Promise<MachineFile>;
+export declare const NO_MACHINE: MachineFile;
+export declare const readMachine: () => MachineFile | null;
+export declare const loadMachine: () => Promise<MachineFile>;
+export declare const setProfileSource: (source: ProfileSource) => Promise<MachineFile>;
+export declare const setDev: (name: string, path: string | null) => Promise<MachineFile>;
+export declare const setCloud: (etag: string) => Promise<MachineFile>;
+export declare const setAccount: (accountId: string) => Promise<MachineFile>;
+export declare const forgetAccount: () => Promise<MachineFile>;
+export declare const accountMismatch: (machine: MachineFile, userId: string | null) => Error | null;

package/dist/core/profile/machine.js

@@ -2,59 +2,82 @@ import { randomBytes } from 'node:crypto';
 import { mkdirSync, readFileSync } from 'node:fs';
 import { hostname } from 'node:os';
 import { dirname } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
 import { withFileLock } from '../../lib/fs/file-lock.js';
 import { isRecord, writeJsonAtomic } from '../../lib/fs/json-file.js';
 import { machinePath } from '../paths.js';
-export const MACHINE_ID = /^m_[0-9a-f]{8}$/;
-const SOURCES = ['cloud', 'file', 'default'];
-const readRaw = (path) => {
-    try {
-        return JSON.parse(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-};
-const defaultDeps = {
-    path: machinePath,
-    read: readRaw,
-    write: (path, machine) => {
-        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-        writeJsonAtomic(path, machine);
-    },
-    lock: (path, fn) => withFileLock(path, fn),
-    hostname: () => hostname(),
-    newId: () => `m_${randomBytes(4).toString('hex')}`,
+// Without machine.json: no dev paths and no `off` list; reading never creates it.
+export const NO_MACHINE = {
+    id: '',
+    name: '',
+    dev: {},
+    profileSource: 'default',
+    accountId: null,
+    profileEtag: null,
 };
+const MACHINE_ID = /^m_[0-9a-f]{8}$/;
+const SOURCES = ['cloud', 'file', 'default'];
+const KEYS = Object.keys(NO_MACHINE).length;
 const isDevMap = (value) => isRecord(value) && Object.values(value).every((path) => typeof path === 'string');
-// Strict: anything but the exact v1 shape is treated as absent, so no old file is migrated.
-export const parseMachine = (raw) => {
-    if (!isRecord(raw) || Object.keys(raw).length !== 4)
+const isTextOrNull = (value) => value === null || (typeof value === 'string' && value !== '');
+// Strict: anything but the exact shape is treated as absent, so no old file is migrated.
+const parseMachine = (raw) => {
+    if (!isRecord(raw) || Object.keys(raw).length !== KEYS)
         return null;
-    const { id, name, dev, profileSource } = raw;
+    const { id, name, dev, profileSource, accountId, profileEtag } = raw;
     if (typeof id !== 'string' || !MACHINE_ID.test(id))
         return null;
-    if (typeof name !== 'string' || name === '')
+    if (typeof name !== 'string' || name === '' || !isDevMap(dev))
+        return null;
+    if (typeof profileSource !== 'string' || !SOURCES.includes(profileSource))
         return null;
-    if (!isDevMap(dev) || typeof profileSource !== 'string' || !SOURCES.includes(profileSource))
+    if (!isTextOrNull(accountId) || !isTextOrNull(profileEtag))
         return null;
-    return { id, name, dev, profileSource: profileSource };
+    const source = profileSource;
+    return { id, name, dev, profileSource: source, accountId, profileEtag };
 };
-// Re-read under the lock so two first runs agree on one id.
-const create = (deps, path) => {
-    const fresh = parseMachine(deps.read(path));
-    if (fresh)
-        return fresh;
-    const machine = {
-        id: deps.newId(),
-        name: deps.hostname(),
-        dev: {},
-        profileSource: 'default',
-    };
-    deps.write(path, machine);
-    return machine;
+// Read only: null when absent or not exactly the current shape, and nothing is written.
+export const readMachine = () => {
+    try {
+        return parseMachine(JSON.parse(readFileSync(machinePath(), 'utf-8')));
+    }
+    catch {
+        return null;
+    }
 };
-export const loadMachine = async (deps = defaultDeps) => {
-    const path = deps.path();
-    return parseMachine(deps.read(path)) ?? deps.lock(path, () => create(deps, path));
+const save = (machine) => {
+    mkdirSync(dirname(machinePath()), { recursive: true, mode: 0o700 });
+    writeJsonAtomic(machinePath(), machine);
+    return machine;
 };
+// Re-read under the lock so two first runs agree on one id.
+const readOrCreate = () => readMachine() ??
+    save({ ...NO_MACHINE, id: `m_${randomBytes(4).toString('hex')}`, name: hostname() });
+export const loadMachine = async () => readMachine() ?? withFileLock(machinePath(), readOrCreate);
+// Under the lock; written only when `change` changed something.
+const update = async (change) => withFileLock(machinePath(), () => {
+    const machine = readOrCreate();
+    const next = change(machine);
+    return isDeepStrictEqual(next, machine) ? machine : save(next);
+});
+export const setProfileSource = async (source) => update((machine) => ({ ...machine, profileSource: source }));
+// One dev entry by package name: a real path adds or replaces it, null removes it.
+export const setDev = async (name, path) => update((machine) => {
+    const dev = Object.fromEntries(Object.entries(machine.dev).filter(([pkg]) => pkg !== name));
+    return { ...machine, dev: path === null ? dev : { ...dev, [name]: path } };
+});
+// After a pull or a push: profile.json mirrors the account's profile at `etag`.
+export const setCloud = async (etag) => update((machine) => ({ ...machine, profileSource: 'cloud', profileEtag: etag }));
+export const setAccount = async (accountId) => update((machine) => ({ ...machine, accountId }));
+// `setup --disconnect`: no account; a copy of the account's profile becomes this machine's own.
+export const forgetAccount = async () => update((machine) => ({
+    ...machine,
+    accountId: null,
+    profileEtag: null,
+    profileSource: machine.profileSource === 'cloud' ? 'default' : machine.profileSource,
+}));
+// A machine stays with the account it was first set up with until `setup --disconnect`.
+export const accountMismatch = (machine, userId) => machine.accountId === null || userId === null || machine.accountId === userId
+    ? null
+    : new Error(`this machine is connected to account ${machine.accountId}, but you are signed in as ` +
+        `${userId}; run agentage setup --disconnect, then agentage setup`);

package/dist/core/profile/merge.d.ts

@@ -7,5 +7,5 @@ export interface Effective {
     dev: Record<string, string>;
     config: ConfigMap;
 }
-export declare const mergeConfig: (shared: ConfigMap, local: ConfigMap) => ConfigMap;
 export declare const effective: (profile: Profile | null, machine: MachineFile) => Effective;
+export declare const keepMachine: (next: Profile, current: Profile | null, machineId: string) => Profile;

package/dist/core/profile/merge.js

@@ -1,12 +1,12 @@
 import {} from './machine.js';
 import {} from './schema.js';
 // Machine values replace shared ones per key; no deep merge, so arrays are replaced whole.
-export const mergeConfig = (shared, local) => {
+const mergeConfig = (shared, local) => {
     const ids = [...new Set([...Object.keys(shared), ...Object.keys(local)])].sort();
     return Object.fromEntries(ids.map((id) => [id, { ...shared[id], ...local[id] }]));
 };
 export const effective = (profile, machine) => {
-    const install = { ...profile?.plugins };
+    const install = { ...profile?.extensions };
     const self = profile?.machines[machine.id];
     const off = self?.off ?? [];
     const kept = Object.keys(install).filter((name) => !off.includes(name));
@@ -14,3 +14,8 @@ export const effective = (profile, machine) => {
     const config = mergeConfig(profile?.config ?? {}, self?.config ?? {});
     return { install, load, off, dev: { ...machine.dev }, config };
 };
+// `setup --profile` replaces the shared fields; this machine's own `off` and `config` survive.
+export const keepMachine = (next, current, machineId) => {
+    const self = current?.machines[machineId];
+    return self ? { ...next, machines: { ...next.machines, [machineId]: self } } : next;
+};

package/dist/core/profile/profile.d.ts

@@ -1,6 +1,6 @@
-import { type ProfileParse } from './schema.js';
-export interface ProfileDeps {
-    path: () => string;
-    readText: (path: string) => string | null;
-}
-export declare const readProfile: (deps?: ProfileDeps) => ProfileParse | null;
+import { type Profile, type ProfileParse } from './schema.js';
+export declare const defaultProfile: () => Profile;
+export declare const parseProfileText: (raw: string) => ProfileParse;
+export declare const readProfile: () => ProfileParse | null;
+export declare const editableProfile: () => Profile;
+export declare const mutateProfile: (fn: (current: Profile | null) => Profile) => Promise<Profile>;