sideby 0.0.0-stage → 0.1.0

package/dist/src/runtime.js

@@ -0,0 +1,371 @@
+// The one service layer the CLI and the Panel share. Frozen contract for v0.1 (plan: 审核修订).
+import { discoverAccounts, resolveRef } from './core/accounts.js';
+import { addConfigAlias, aliasAccount, aliasArgs, aliasProblem, aliasRefs, loadConfig, removeConfigAlias, } from './core/config.js';
+import { createAccount } from './core/create.js';
+import { applyFixes, runDoctor } from './core/doctor.js';
+import { UserError } from './core/errors.js';
+import { planHandoff } from './core/handoff.js';
+import { identityOf } from './core/identity.js';
+import { mergeDoctorHistory, readDoctorHistory, writeDoctorHistory, } from './core/last-doctor.js';
+import { prepareLaunch, which } from './core/launch.js';
+import { resolvePaths } from './core/paths.js';
+import { SHELLS, shellInitScript, writeShellInitFile, } from './core/shell-init.js';
+import { packageVersion } from './core/version.js';
+import { BUILTIN_PLUGINS } from './families/index.js';
+import { HookBus } from './plugins/bus.js';
+import { loadPlugins } from './plugins/loader.js';
+export class UnknownFamilyError extends UserError {
+}
+/**
+ * A Family's identity reader, kept to the identity fields with the expected types. A reader that throws, or returns
+ * anything else, gives undefined: identity is a display nicety and never a problem of the Account.
+ */
+async function readIdentity(f, account) {
+    if (!f.identity || account.kind === 'api')
+        return undefined;
+    try {
+        const r = await f.identity(account);
+        return identityOf(r?.email, r?.org);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function createRuntime(opts = {}) {
+    const env = opts.env ?? process.env;
+    const paths = resolvePaths(env);
+    const config = await loadConfig(paths.configFile);
+    const bus = new HookBus();
+    const loaded = await loadPlugins({
+        builtins: opts.builtins ?? BUILTIN_PLUGINS,
+        config,
+        bus,
+        userPluginsDir: paths.userPluginsDir,
+        home: paths.home,
+    });
+    const families = loaded.families;
+    const ignore = new Set(config.ignore ?? []);
+    const now = opts.now ?? (() => new Date());
+    const familyOf = (id) => {
+        const f = families.get(id);
+        if (!f)
+            throw new UnknownFamilyError(`unknown family "${id}"; available: ${[...families.keys()].join(', ') || 'none (check `sideby plugins`)'}`);
+        return f;
+    };
+    // Merge `extraSharedItems` from the config into each Family's list.
+    for (const [id, extra] of Object.entries(config.extraSharedItems ?? {})) {
+        const f = families.get(id);
+        if (f)
+            families.set(id, { ...f, sharedItems: [...f.sharedItems, ...extra] });
+    }
+    const accounts = async () => {
+        const out = [];
+        for (const f of families.values())
+            out.push(...(await discoverAccounts(f, paths.home, ignore)));
+        return out;
+    };
+    const readContext = () => ({
+        home: paths.home,
+        now: now(),
+        stateDir: paths.stateDir,
+        env,
+    });
+    /** The config value of the alias `name`, from own keys only (`constructor` is not an alias unless configured). */
+    const ownAlias = (name) => config.aliases && Object.hasOwn(config.aliases, name) ? config.aliases[name] : undefined;
+    /** The config value of `ref` when it names an alias (no colon), as `resolveRef` reads it. */
+    const aliasValue = (ref) => (ref.includes(':') ? undefined : ownAlias(ref));
+    const aliasEdit = async (alias, status, value) => {
+        const args = aliasArgs(value);
+        const files = await rt.writeShellInitFiles();
+        return {
+            ok: files.every((f) => f.ok),
+            alias,
+            status,
+            ...(value === undefined ? {} : { account: aliasAccount(value) }),
+            ...(args.length ? { args } : {}),
+            ...(files.length ? { shellInitFiles: files } : {}),
+        };
+    };
+    const rt = {
+        paths,
+        config,
+        env,
+        families,
+        plugins: loaded.plugins,
+        pluginErrors: loaded.errors,
+        async familyInfo() {
+            return Promise.all([...families.values()].map(async (f) => ({
+                id: f.id,
+                title: f.title,
+                bin: f.bin,
+                installUrl: f.installUrl,
+                installed: (await which(f.bin, env)) !== null,
+                plugin: loaded.familyOwner.get(f.id) ?? 'unknown',
+            })));
+        },
+        accounts,
+        async resolve(ref) {
+            return resolveRef(ref, await accounts(), aliasRefs(config.aliases));
+        },
+        async status(account) {
+            const f = familyOf(account.family);
+            const problems = [];
+            // Plugin readers may throw synchronously or reject; either way the Account still gets a status.
+            const safe = async (what, fn) => {
+                if (!fn)
+                    return undefined;
+                try {
+                    return await fn();
+                }
+                catch (err) {
+                    problems.push(`${what}: ${err?.message ?? String(err)}`);
+                    return undefined;
+                }
+            };
+            const [installed, login, model, identity] = await Promise.all([
+                which(f.bin, env),
+                account.kind === 'api'
+                    ? undefined
+                    : safe('login state', f.loginState && (() => f.loginState(account))),
+                safe('model', f.model && (() => f.model(account))),
+                readIdentity(f, account),
+            ]);
+            return {
+                ...account,
+                familyTitle: f.title,
+                hostInstalled: installed !== null,
+                login: account.kind === 'api' ? 'not-needed' : (login ?? 'unknown'),
+                ...(model ? { model } : {}),
+                ...(identity ? { identity } : {}),
+                ...(problems.length ? { problems } : {}),
+            };
+        },
+        async doctor(o = {}) {
+            return (await rt.doctorWithHistory(o)).report;
+        },
+        async doctorWithHistory(o = {}) {
+            let list = await accounts();
+            let fams = families;
+            let scope = { kind: 'all' };
+            if (o.target) {
+                if (families.has(o.target)) {
+                    list = list.filter((a) => a.family === o.target);
+                    fams = new Map([[o.target, families.get(o.target)]]);
+                    scope = { kind: 'family', family: o.target };
+                }
+                else {
+                    const one = resolveRef(o.target, list, aliasRefs(config.aliases));
+                    list = [one];
+                    fams = new Map([[one.family, familyOf(one.family)]]);
+                    scope = { kind: 'account', ref: one.ref };
+                }
+            }
+            const input = {
+                home: paths.home,
+                families: fams,
+                accounts: list,
+                bus,
+                force: Boolean(o.force),
+                // Checked for every Family in the run, also when Doctor is aimed at one Account, so the saved result
+                // of that Family keeps its skill warning.
+                skillVersion: packageVersion(),
+            };
+            let report = await runDoctor(input);
+            if (o.fix) {
+                const fixes = await applyFixes(report);
+                report = { ...(await runDoctor(input)), fixes };
+            }
+            const history = mergeDoctorHistory(await readDoctorHistory(paths.stateDir), report, scope, now());
+            if (o.persist !== false)
+                await writeDoctorHistory(paths.stateDir, history);
+            return { report, history };
+        },
+        doctorHistory: () => readDoctorHistory(paths.stateDir),
+        async quotaSetups() {
+            const out = [];
+            for (const f of families.values()) {
+                if (!f.quotaSetup)
+                    continue;
+                const setup = rt.quotaSetup(f.id);
+                out.push({ family: f.id, summary: setup.summary, plan: await setup.plan() });
+            }
+            return out;
+        },
+        quotaSetup(familyId) {
+            const f = familyOf(familyId);
+            const setup = f.quotaSetup;
+            if (!setup)
+                throw new UserError(`${f.title} needs no quota setup`);
+            // One rule for every adapter: a setup that throws is reported, never crashes the caller. The message
+            // is the error's own text; setup implementations must not put file contents into it.
+            const blocked = (err) => ({
+                status: 'blocked',
+                file: '',
+                diff: '',
+                message: err?.message ?? String(err),
+            });
+            return {
+                family: f.id,
+                summary: setup.summary,
+                // Promise.resolve().then also catches a setup that throws synchronously.
+                plan: () => Promise.resolve()
+                    .then(() => setup.plan(readContext()))
+                    .catch(blocked),
+                apply: () => Promise.resolve()
+                    .then(() => setup.apply(readContext()))
+                    .catch(blocked),
+                teardown: () => Promise.resolve()
+                    .then(() => setup.teardown(readContext()))
+                    .catch((err) => ({
+                    ok: false,
+                    message: err?.message ?? String(err),
+                })),
+            };
+        },
+        async createAccount(familyId, name, o = {}) {
+            const family = familyOf(familyId);
+            const alias = o.alias?.trim() || undefined;
+            const ref = `${family.id}:${name}`;
+            if (alias) {
+                const problem = rt.aliasProblem(alias, ref);
+                if (problem)
+                    throw new UserError(`${problem}; nothing was created`, { code: 'alias-invalid' });
+            }
+            const created = await createAccount({
+                family,
+                name,
+                api: Boolean(o.api),
+                home: paths.home,
+                bus,
+                accounts: await discoverAccounts(family, paths.home, ignore),
+            });
+            if (alias) {
+                try {
+                    // An alias that already starts this Account keeps its arguments; creating the Account does not change them.
+                    const r = await addConfigAlias(paths.configFile, alias, created.account.ref, aliasArgs(ownAlias(alias)));
+                    config.aliases = r.aliases;
+                    created.alias = {
+                        name: alias,
+                        added: true,
+                        ...(r.status === 'exists' ? { message: 'already in the config' } : {}),
+                    };
+                }
+                catch (err) {
+                    created.alias = {
+                        name: alias,
+                        added: false,
+                        message: `${created.account.ref} was created, but the alias was not added: ${err.message}`,
+                    };
+                }
+            }
+            const files = await rt.writeShellInitFiles();
+            if (files.length)
+                created.shellInitFiles = files;
+            created.ok = created.ok && created.alias?.added !== false && files.every((f) => f.ok);
+            return created;
+        },
+        async addAlias(alias, target, args = []) {
+            const bad = aliasProblem(alias);
+            if (bad)
+                throw new UserError(`alias "${alias}" ${bad} (it becomes a shell function name)`);
+            // Resolve first so the config only ever names an Account that exists, by its ref.
+            const account = resolveRef(target, await accounts(), aliasRefs(config.aliases));
+            const r = await addConfigAlias(paths.configFile, alias, account.ref, args);
+            config.aliases = r.aliases;
+            return aliasEdit(alias, r.status, r.aliases[alias]);
+        },
+        async removeAlias(alias) {
+            const before = ownAlias(alias);
+            const r = await removeConfigAlias(paths.configFile, alias);
+            config.aliases = r.aliases;
+            return aliasEdit(alias, r.status, r.status === 'removed' ? before : undefined);
+        },
+        aliasProblem(alias, ref) {
+            const bad = aliasProblem(alias);
+            if (bad)
+                return `alias "${alias}" ${bad} (it becomes a shell function name)`;
+            const value = ownAlias(alias);
+            const taken = value === undefined ? undefined : aliasAccount(value);
+            if (taken !== undefined && taken !== ref)
+                return `alias "${alias}" already starts ${taken}; pick another name`;
+            return null;
+        },
+        async shellInitScript() {
+            return shellInitScript(await accounts(), config.aliases);
+        },
+        async writeShellInitFiles(shells = SHELLS) {
+            const out = [];
+            for (const shell of shells) {
+                const file = config.shellInitFile?.[shell];
+                if (file)
+                    out.push(await writeShellInitFile(shell, file, paths.home, await rt.shellInitScript(shell)));
+            }
+            return out;
+        },
+        async prepareLaunch(ref, userArgs, command) {
+            const account = resolveRef(ref, await accounts(), aliasRefs(config.aliases));
+            return prepareLaunch({
+                account,
+                family: familyOf(account.family),
+                baseEnv: env,
+                accountArgs: config.accounts?.[account.ref]?.args ?? [],
+                // An alias's arguments come before the user's; the Family sees both as the user's choice (ADR-0005).
+                userArgs: command === 'run' ? [...aliasArgs(aliasValue(ref)), ...userArgs] : userArgs,
+                command,
+                bus,
+            });
+        },
+        async quota(account) {
+            if (account.kind === 'api')
+                return { status: 'unavailable', reason: 'api-account' };
+            const f = familyOf(account.family);
+            if (!f.readQuota)
+                return { status: 'unavailable', reason: 'no-source' };
+            try {
+                return await f.readQuota(account, readContext());
+            }
+            catch (err) {
+                return { status: 'unavailable', reason: 'unrecognized', detail: err.message };
+            }
+        },
+        async usage(account) {
+            const f = familyOf(account.family);
+            if (!f.readUsage)
+                return { status: 'unavailable', reason: 'no-source' };
+            try {
+                return await f.readUsage(account, readContext());
+            }
+            catch (err) {
+                return { status: 'unavailable', reason: 'unrecognized', detail: err.message };
+            }
+        },
+        async handoff(familyId, o = {}) {
+            const f = familyOf(familyId);
+            const list = (await accounts()).filter((a) => a.family === f.id);
+            if (!f.readQuota)
+                throw new UserError(`${f.title} has no public quota source, so sideby cannot tell which account has room; pick one yourself: ${list.map((a) => `sideby run ${a.ref}`).join(', ') || `sideby new ${f.id} <name>`}`, { code: 'no-quota-source' });
+            if (list.length === 0)
+                throw new UserError(`no ${f.title} accounts yet; create one with \`sideby new ${f.id} <name>\``, {
+                    code: 'no-accounts',
+                });
+            // Only the login state and Quota: no identity, model or Host lookups are needed to rank.
+            const loginOf = async (a) => {
+                if (a.kind === 'api')
+                    return 'not-needed';
+                try {
+                    return (await f.loginState?.(a)) ?? 'unknown';
+                }
+                catch {
+                    return 'unknown';
+                }
+            };
+            const candidates = await Promise.all(list.map(async (a) => {
+                const [login, quota] = await Promise.all([loginOf(a), rt.quota(a)]);
+                return { ref: a.ref, name: a.name, isMain: a.isMain, kind: a.kind, login, quota };
+            }));
+            return planHandoff(f.id, candidates, readContext().now, o);
+        },
+        readContext,
+    };
+    return rt;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,278 @@
+export type ShareMode = 'link' | 'copy' | 'link-or-copy' | 'link-or-local' | 'local' | 'local-if-api' | 'info' | 'json-key';
+export interface SharedItemDef {
+    /** Path inside the Account directory, for example `skills` or `.claude.json`. */
+    path: string;
+    mode: ShareMode;
+    /** Main-side source relative to HOME, when it does not live in the Main Account directory (`.claude.json`). */
+    mainPath?: string;
+    /** For `json-key`: the top-level key mirrored from the main file. */
+    key?: string;
+    /** The Host refuses to start when this path is a symlink (Grok sandbox). */
+    noSymlink?: boolean;
+    /** Holds credentials: must be a regular file with mode 600. Contents are never read. */
+    credential?: boolean;
+    /** Host message quoted when the item breaks a Host rule. */
+    hostMessage?: string;
+}
+export interface FamilyLayout {
+    /** Main Account directory relative to HOME, for example `.claude` or `.pi/agent`. */
+    main: string;
+    /** Other Accounts relative to HOME, with `<name>` in the first path segment: `.claude-<name>`, `.pi-<name>/agent`. */
+    account: string;
+}
+export type LoginState = 'logged-in' | 'logged-out' | 'unknown';
+/**
+ * A Family's mark for the Panel: one SVG path in a 24x24 view box, drawn inline. sideby checks it when the
+ * Plugin registers; an invalid logo is dropped with a plugin error and the Panel shows the Family's initials.
+ */
+export interface FamilyLogo {
+    /** SVG path data: only commands, numbers, spaces, commas, dots, `+` and `-`. At most 20000 characters. */
+    path: string;
+    /** Hex brand color such as `#D97757`. Without one the mark uses the text color, so it works in light and dark mode. */
+    color?: string;
+    /** Name of the mark for tooltips; defaults to the Family title. */
+    title?: string;
+    fillRule?: 'nonzero' | 'evenodd';
+}
+export interface FamilyDef {
+    id: string;
+    title: string;
+    /** Mark shown on the Panel's cards, lists and the Tool select; without one the Panel shows the id's initials. */
+    logo?: FamilyLogo;
+    /** Host executable looked up on PATH. */
+    bin: string;
+    installUrl: string;
+    /** Environment variable that selects the Account directory. Not set for the Main Account. */
+    selectVar: string;
+    layout: FamilyLayout;
+    /**
+     * Entries that prove a directory is this Family's Account (besides a Secret File or an empty directory).
+     * Defaults to the Shared Item paths; set it when a shared name is generic, like Claude's `plugins`.
+     */
+    markers?: string[];
+    /**
+     * Whether a Secret File makes an Account an API Account (default true). pi keeps `proxy.env` in every
+     * Account for provider keys, so for pi it is loaded at Launch but says nothing about the login.
+     */
+    secretFileMeansApi?: boolean;
+    /** Cleared before every Launch, for every Account. */
+    hijackVars: string[];
+    /** Variables written, commented out, into a new API Account's Secret File. */
+    apiVars: string[];
+    sharedItems: SharedItemDef[];
+    /** Arguments for the Host's sign-in command, or null when sign-in happens inside the Host. */
+    login: {
+        args: string[] | null;
+        hint: string;
+    };
+    /** Arguments sideby adds before the Account's and the user's arguments. */
+    defaultArgs?(account: Account, userArgs: readonly string[]): string[];
+    loginState?(account: Account): Promise<LoginState>;
+    model?(account: Account): Promise<string | undefined>;
+    /**
+     * Who the Account is signed in as, from the Host's own login file: identity fields such as the email and the
+     * organization only, never a token or any other credential value (ADR-0003). Return undefined when unknown; an
+     * error is treated the same way and never shown as a problem.
+     */
+    identity?(account: Account): Promise<AccountIdentity | undefined>;
+    readQuota?(account: Account, ctx: ReadContext): Promise<QuotaResult>;
+    readUsage?(account: Account, ctx: ReadContext): Promise<UsageResult>;
+    /** One-time, reversible change that lets the Host report Quota (Claude: status line wrapper). */
+    quotaSetup?: QuotaSetup;
+}
+/** Identity fields of a signed-in Account. */
+export interface AccountIdentity {
+    email?: string;
+    /** Organization or team, when it is not just the personal default. */
+    org?: string;
+}
+export interface QuotaSetupPlan {
+    /** `enabled`: already on; `ready`: apply would make `diff`; `blocked`: cannot apply, see `message`. */
+    status: 'enabled' | 'ready' | 'blocked';
+    /** File the change touches. */
+    file: string;
+    /** Unified diff of the change, empty when nothing would change. */
+    diff: string;
+    message: string;
+}
+export interface QuotaSetup {
+    /** One sentence shown before the user confirms. */
+    summary: string;
+    plan(ctx: ReadContext): Promise<QuotaSetupPlan>;
+    /** Re-plans and applies only when the plan is `ready`. */
+    apply(ctx: ReadContext): Promise<QuotaSetupPlan>;
+    /** Restores the original bytes only if the file is still exactly what `apply` wrote. */
+    teardown(ctx: ReadContext): Promise<{
+        ok: boolean;
+        message: string;
+        diff?: string;
+    }>;
+}
+export interface Account {
+    family: string;
+    /** `main` for the Main Account. */
+    name: string;
+    /** `<family>:<name>` */
+    ref: string;
+    dir: string;
+    isMain: boolean;
+    kind: 'subscription' | 'api';
+    /** Path of the Secret File for API Accounts. */
+    secretFile?: string;
+}
+export interface ReadContext {
+    home: string;
+    now: Date;
+    /** sideby state directory (quota caches live here). */
+    stateDir: string;
+    /** sideby's own environment (PATH lookups); never the Host's. */
+    env: Env;
+}
+export interface QuotaWindow {
+    /** `5h`, `7d`, or `<n>m` for unknown window lengths. */
+    label: string;
+    windowMinutes: number;
+    usedPercent: number;
+    /** ISO timestamp. */
+    resetsAt: string;
+}
+export type QuotaUnavailableReason = 'not-enabled' | 'no-session' | 'unrecognized' | 'no-source' | 'api-account';
+export type QuotaResult = {
+    status: 'ok';
+    windows: QuotaWindow[];
+    observedAt: string;
+    source: string;
+    plan?: string;
+} | {
+    status: 'unavailable';
+    reason: QuotaUnavailableReason;
+    detail?: string;
+};
+export interface TokenTotals {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+}
+export type UsageResult = ({
+    status: 'ok';
+    days: number;
+    sessions: number;
+    /**
+     * Tokens per local calendar day (`YYYY-MM-DD`), `days` entries ending today, oldest first, days without
+     * records as 0. It can sum to less than `totalTokens`, which also covers the part of the oldest day
+     * inside the rolling window.
+     */
+    daily?: {
+        date: string;
+        totalTokens: number;
+    }[];
+    /** ISO time of the newest record the reader saw, not later than now. */
+    lastActivityAt?: string;
+} & TokenTotals) | {
+    status: 'unavailable';
+    reason: 'no-source' | 'no-session' | 'unrecognized';
+    detail?: string;
+};
+export type FindingLevel = 'ok' | 'warn' | 'fail';
+export interface FixResult {
+    ok: boolean;
+    message: string;
+}
+export interface Finding {
+    level: FindingLevel;
+    /** Account ref the Finding is about. */
+    account: string;
+    /** Shared Item path or check name. */
+    item: string;
+    /** Stable machine code such as `link.real-file`. */
+    code: string;
+    message: string;
+    /** What the user should do; never contains credential values. */
+    hint?: string;
+    /** `core` or the Plugin name. */
+    source: string;
+    fixable: boolean;
+    /** Present when `fixable`; not serialized. */
+    fix?: () => Promise<FixResult>;
+}
+/** What a `doctor.check` hook returns; sideby fills `account` and `source`. */
+export type CheckResult = Omit<Finding, 'account' | 'source' | 'fixable'> & {
+    fixable?: boolean;
+};
+export type Env = Record<string, string | undefined>;
+export interface LaunchContext {
+    account: Account;
+    family: FamilyDef;
+    /** Environment the Host will receive; mutate to change it. */
+    env: Env;
+    /** Arguments the Host will receive; mutate to change them. */
+    args: string[];
+    config: Record<string, unknown>;
+    /** `run` or `login`. */
+    command: 'run' | 'login';
+}
+export interface CreateBeforeContext {
+    family: FamilyDef;
+    /** Name of the Account about to be created, already checked against the name rules. */
+    name: string;
+    /** Whether it will be an API Account (`sideby new --api`, or "API key account" in the Panel). */
+    api: boolean;
+    /** The Family's existing Accounts, the Main Account included. */
+    accounts: Account[];
+    config: Record<string, unknown>;
+}
+export interface CreatedContext {
+    account: Account;
+    family: FamilyDef;
+    config: Record<string, unknown>;
+    log(message: string): void;
+}
+export interface DoctorContext {
+    account: Account;
+    family: FamilyDef;
+    config: Record<string, unknown>;
+}
+export interface HookFilter {
+    family?: string;
+}
+export interface HookEvents {
+    'launch.before': {
+        ctx: LaunchContext;
+        result: void;
+    };
+    'account.create.before': {
+        ctx: CreateBeforeContext;
+        result: void;
+    };
+    'account.created': {
+        ctx: CreatedContext;
+        result: void;
+    };
+    'doctor.check': {
+        ctx: DoctorContext;
+        result: CheckResult[] | undefined;
+    };
+}
+export type HookEvent = keyof HookEvents;
+export type HookHandler<E extends HookEvent> = (ctx: HookEvents[E]['ctx']) => HookEvents[E]['result'] | Promise<HookEvents[E]['result']>;
+export interface PluginFs {
+    /** Atomic write via a temp file in the same directory; `mode` defaults to 0o600. */
+    writeFileAtomic(path: string, data: string | Uint8Array, mode?: number): Promise<void>;
+}
+export interface PluginApi {
+    family(def: FamilyDef): void;
+    on<E extends HookEvent>(event: E, handler: HookHandler<E>): void;
+    on<E extends HookEvent>(event: E, filter: HookFilter, handler: HookHandler<E>): void;
+    /**
+     * Returns an error that, when thrown from `launch.before` or `account.create.before`, stops the Launch or the
+     * new Account with this message. Say what to do instead: the CLI and the Panel show it as is.
+     */
+    abort(message: string): Error;
+    fs: PluginFs;
+}
+export interface Plugin {
+    name: string;
+    register(api: PluginApi): void | Promise<void>;
+}

package/dist/src/types.js

@@ -0,0 +1,3 @@
+// Public contract shared by sideby core, built-in Families and third-party Plugins.
+// Plugins may only `import type` from this module (ADR-0002); values reach them through PluginApi.
+export {};

package/dist/testing/demo.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltinPlugin } from '../src/plugins/loader.ts';
+import type { FamilyDef, Plugin, SharedItemDef } from '../src/types.ts';
+export declare const DEMO_ITEMS: SharedItemDef[];
+export declare function demoFamily(overrides?: Partial<FamilyDef>): FamilyDef;
+export declare function demoPlugin(def?: FamilyDef, extra?: Plugin['register']): Plugin;
+export declare function asBuiltin(plugin: Plugin, defaultEnabled?: boolean): BuiltinPlugin;
+/** Populates a Main Account with one source for every demo Shared Item. */
+export declare function seedDemoMain(write: (rel: string, data: string, mode?: number) => Promise<string>): Promise<void>;