agent-shim 7.13.1 → 7.14.0

package/dist/types/config/store.d.ts

@@ -1,46 +0,0 @@
-import type { z } from "zod";
-/**
- * Filesystem primitives `store.ts` needs, injected so tests can simulate a crash between the temp-file write and the rename without touching real process semantics (e.g. actually killing the process mid-write). The default implementation (`nodeStoreFs`) is real `node:fs`, used by every CLI adapter in normal operation and by this module's own tests when exercising the real atomic-rename behaviour end to end.
- */
-export interface StoreFs {
-    /** Reads a file's contents as UTF-8 text, or returns undefined when it does not exist. */
-    readonly readFileUtf8: (filePath: string) => string | undefined;
-    /** Writes a file's full contents as UTF-8 text, creating or truncating it. */
-    readonly writeFileUtf8: (filePath: string, contents: string) => void;
-    /** Atomically renames `from` to `to` (same filesystem — both are always in the same directory in this module's own usage). */
-    readonly renameSync: (from: string, to: string) => void;
-    /** Creates a directory (and any missing parents), succeeding silently if it already exists. */
-    readonly mkdirSync: (dirPath: string) => void;
-    /** Removes a file, succeeding silently if it does not exist — used to clean up a stray temp file after a failed rename. */
-    readonly unlinkSync: (filePath: string) => void;
-}
-/** The real `node:fs`-backed implementation of `StoreFs`, used by every CLI adapter in normal operation. */
-export declare const nodeStoreFs: StoreFs;
-/**
- * Reads and validates one JSON config file against `schema`.
- *
- * Returns undefined when the file does not exist. Throws `ConfigValidationError` (the same error type `src/config/load.ts` throws for every other config file in this project) when it exists but fails validation.
- */
-export declare function readJson<S extends z.ZodType>(filePath: string, schema: S, storeFs?: StoreFs): z.infer<S> | undefined;
-/**
- * Writes `contents` as UTF-8 text to `filePath` atomically: writes to a temp file in the *same directory* first, then renames it into place. A crash (or thrown error) between the write and the rename leaves the original file at `filePath` completely untouched — the failure mode this exists to prevent is a config file left half-written after an interrupted process.
- *
- * The temp file's name includes the destination's own basename, the process id, and a random UUID, so two concurrent writers (even to the same file, even from two processes) never collide on the same temp path.
- */
-export declare function writeTextAtomic(filePath: string, contents: string, storeFs?: StoreFs): void;
-/** Writes `data` as pretty-printed JSON to `filePath`, via `writeTextAtomic`. */
-export declare function writeJsonAtomic(filePath: string, data: unknown, storeFs?: StoreFs): void;
-/** Inputs to `applyPatch`. */
-export interface ApplyPatchOptions<T> {
-    /** Used as the base to merge `patch` into when `filePath` does not exist yet. Required for a file that may not exist yet (e.g. a config profile's own first `set` before it was ever written by `create`); omit only when the file is guaranteed to already exist. */
-    readonly defaults?: T;
-    readonly storeFs?: StoreFs;
-}
-/**
- * Reads `filePath` (or falls back to `options.defaults` when it does not exist), shallow-merges `patch` over the top-level keys of the result, re-validates the merged object against `schema`, and writes it back atomically.
- *
- * The merge is deliberately shallow — only top-level keys of the parsed config are replaced wholesale by the corresponding key in `patch`. A caller that wants to add one key to a nested object (e.g. one more category inside `categories`) must read the existing nested object itself and pass the already-merged nested object as part of `patch`; `applyPatch` does not recurse into nested objects on its own.
- *
- * Throws when the file does not exist and no `defaults` were given, and re-throws `ConfigValidationError` (via the underlying `schema.parse`) when the merged result does not validate.
- */
-export declare function applyPatch<S extends z.ZodType>(filePath: string, schema: S, patch: Readonly<Partial<z.infer<S>>>, options?: ApplyPatchOptions<z.infer<S>>): z.infer<S>;

package/dist/types/configProfilesStore.d.ts

@@ -1,61 +0,0 @@
-import { type ConfigProfile, type GlobalConfig, type LaunchFlags } from "./config/schema";
-import { CliError } from "./cliError";
-import type { LayoutPaths } from "./paths";
-/** Raised by any operation that requires a configuration profile to already exist, when it does not. */
-export declare class ProfileNotFoundError extends CliError {
-    readonly profileName: string;
-    constructor(profileName: string);
-}
-/** Raised by `createProfile` (`profile add`) when a profile with the given name already has a file. */
-export declare class ProfileAlreadyExistsError extends CliError {
-    readonly profileName: string;
-    constructor(profileName: string);
-}
-/** Raised when a `--category` patch names something other than one of the four overridable categories (e.g. `secret`, or a typo). */
-export declare class InvalidCategoryNameError extends CliError {
-    readonly categoryName: string;
-    constructor(categoryName: string);
-}
-/** True when a profile file exists for `name`, regardless of whether it validates. */
-export declare function profileExists(paths: LayoutPaths, name: string): boolean;
-export declare function requireProfileExists(paths: LayoutPaths, name: string): void;
-/** Reads and validates one configuration profile, or undefined when it does not exist. */
-export declare function readProfile(paths: LayoutPaths, name: string): ConfigProfile | undefined;
-/**
- * Creates a new configuration profile, empty apart from the optional `extends` list and description. Throws `ProfileAlreadyExistsError` if a profile with this name already has a file, and `ConfigValidationError` when the result fails `ConfigProfileSchema` (e.g. an empty `--extends ""` name), rather than letting the underlying `ZodError` escape as an unhandled crash.
- */
-export declare function createProfile(paths: LayoutPaths, name: string, extendsList?: readonly string[], description?: string): ConfigProfile;
-/** One profile as reported by `listProfiles`. */
-export interface ProfileListEntry {
-    readonly name: string;
-    readonly profile: ConfigProfile;
-}
-/** Lists every configuration profile under `configProfilesDir` that has a valid `<name>.json`. */
-export declare function listProfiles(paths: LayoutPaths): readonly ProfileListEntry[];
-/** Reads the user-global `~/.agent-shim/config.json`, or undefined when it does not exist. */
-export declare function readGlobalConfig(paths: LayoutPaths): GlobalConfig | undefined;
-/** Sets the user-global default configuration profile in `~/.agent-shim/config.json`, creating the file if it doesn't exist yet. Whether the profile exists is the caller's concern: `profile use` checks it first. */
-export declare function setGlobalDefaultProfile(paths: LayoutPaths, name: string): GlobalConfig;
-/**
- * Merges `patch` (from one or more `--category cat=bool` flags) into `profile`'s own `categories` object and writes it back.
- *
- * Throws `InvalidCategoryNameError` for any key that isn't one of the four overridable categories — `secret` can never be toggled by any configuration layer, this included.
- */
-export declare function setProfileCategories(paths: LayoutPaths, name: string, patch: Readonly<Record<string, boolean>>): ConfigProfile;
-/**
- * Merges `patch` (from one or more `--entry "path"=bool` flags) into `profile`'s own `entries` object and writes it back.
- *
- * Key validity (the `<category>/<real-relative-path>` prefix requirement) is enforced by `ConfigProfileSchema`'s own `EntriesSchema` at write time — an invalid key surfaces as the usual `ConfigValidationError`.
- */
-export declare function setProfileEntries(paths: LayoutPaths, name: string, patch: Readonly<Record<string, boolean>>): ConfigProfile;
-/**
- * Merges `patch` into `profile`'s own `launch` object and writes it back. A key present in `patch` with the value `undefined` removes that setting outright (a `--no-launch-provider`, say) rather than overwriting it, and a `launch` object left with no settings is removed too.
- */
-export declare function setProfileLaunchFlags(paths: LayoutPaths, name: string, patch: Readonly<LaunchFlags>): ConfigProfile;
-/** Replaces `profile`'s own `extends` list and/or description; an empty list or an undefined description removes the field. */
-export declare function setProfileMetadata(paths: LayoutPaths, name: string, patch: Readonly<{
-    extends?: readonly string[];
-    description?: string | false;
-}>): ConfigProfile;
-/** Deletes a configuration profile's file. Throws `ProfileNotFoundError` when it does not exist. Nothing that references it by name is rewritten; `agent-shim doctor` reports any identity default, directory rule or `extends` left pointing at it. */
-export declare function removeProfile(paths: LayoutPaths, name: string): void;

package/dist/types/configure.d.ts

@@ -1,170 +0,0 @@
-import type { Command } from "commander";
-import { type CommandDeps } from "./cli/commandDeps";
-import { CliError, UsageError } from "./cliError";
-import type { LogPort } from "./launcher/ports";
-import { type LayoutPaths } from "./paths";
-/** Raised by `configure` when no configuration profile resolves for the identity at the working directory, so there is no tier-three file for a toggle to land in. */
-export declare class NoConfigProfileResolvedError extends CliError {
-    readonly identityName: string;
-    readonly cwd: string;
-    constructor(identityName: string, cwd: string);
-}
-/** Raised by `configure` when standard input is not a terminal: every step of it is a prompt, so there is no non-interactive form to fall back to. */
-export declare class ConfigureNeedsTerminalError extends UsageError {
-    constructor();
-}
-/** Raised by `configure` when no `--identity` was given and nothing else (the environment, a directory pin, the active identity) resolves one. */
-export declare class NoIdentityResolvedError extends UsageError {
-    readonly cwd: string;
-    constructor(cwd: string);
-}
-/** One selectable option, shared by `select` and `multiselect`. */
-interface PromptOption<Value extends string> {
-    readonly value: Value;
-    readonly label: string;
-    readonly hint?: string;
-    /** Visible but not selectable — used for the `secret` category, which no configuration layer may ever toggle. */
-    readonly disabled?: boolean;
-}
-/** Parameters shared by a single-select prompt. */
-export interface SelectParams<Value extends string> {
-    readonly message: string;
-    readonly options: readonly PromptOption<Value>[];
-    /** Which option the cursor starts on. Omit to let the prompt library fall back to its own default (the first option) — pass this explicitly whenever the safest or most common answer isn't the first one listed, so the on-screen reading order and the default-on-Enter answer can differ deliberately rather than being forced to match. */
-    readonly initialValue?: Value;
-}
-/** Parameters for a multi-select prompt. */
-export interface MultiselectParams<Value extends string> {
-    readonly message: string;
-    readonly options: readonly PromptOption<Value>[];
-    readonly initialValues?: readonly Value[];
-}
-/** Parameters for a free-text prompt. */
-export interface TextParams {
-    readonly message: string;
-    readonly placeholder?: string;
-    /** Returns an error string to reject the value and re-prompt, or `undefined` to accept it. */
-    readonly validate?: (value: string) => string | undefined;
-}
-/**
- * The interactive-prompt surface `runConfigure` needs, abstracted so it can be driven by a scripted sequence of pre-programmed answers in tests instead of a real TTY — the same injected-ports pattern `src/launcher/ports.ts` already uses for the filesystem, spawn, and clock.
- *
- * `select`/`multiselect`/`text` resolve to a `symbol` when the user cancels (Ctrl-C), mirroring `@clack/prompts`' own cancellation contract exactly, so `isCancel` is the one place that distinguishes a real answer from a cancellation.
- */
-export interface PromptsPort {
-    readonly select: <Value extends string>(params: SelectParams<Value>) => Promise<Value | symbol>;
-    readonly multiselect: <Value extends string>(params: MultiselectParams<Value>) => Promise<readonly Value[] | symbol>;
-    readonly text: (params: TextParams) => Promise<string | symbol>;
-    /** A type guard, mirroring `@clack/prompts`' own `isCancel` exactly, so a passing check narrows `Value | symbol` down to `Value` at every call site without a further cast. */
-    readonly isCancel: (value: unknown) => value is symbol;
-    readonly cancel: (message?: string) => void;
-    readonly intro: (message?: string) => void;
-    readonly outro: (message?: string) => void;
-}
-export declare const realPromptsPort: PromptsPort;
-/** Where one toggle should be written, per the README's "agent-shim configure: which file it writes to" precedence. */
-export type WriteTarget = {
-    readonly tier: "portable-local";
-    readonly localConfigPath: string;
-} | {
-    readonly tier: "directory-rule";
-    readonly rulePath: string;
-} | {
-    readonly tier: "config-profile";
-    readonly profileName: string;
-};
-/** One directory level's portable-config presence, shallowest-first — as produced by `walkDirectoryAncestors` plus a filesystem existence check at each level. */
-export interface DirectoryLevelPresence {
-    readonly dir: string;
-    /** Whether a committed `.agent-shim.json` already exists at this level. */
-    readonly hasPortable: boolean;
-    /** Whether a gitignored `.agent-shim.local.json` already exists at this level, independent of whether a committed sibling does — this is what makes tier one apply even when only a personal local override was ever created, with no committed file alongside it. */
-    readonly hasPortableLocal: boolean;
-    /** The personal local file a toggle at this level is written into: the former `.claude-use.local.json` when that is the only one that exists, so its settings are not shadowed by a new file, otherwise `.agent-shim.local.json`. */
-    readonly portableLocalFilename: string;
-}
-/** Inputs to `chooseWriteTarget`. */
-export interface ChooseWriteTargetParams {
-    readonly cwd: string;
-    readonly home: string;
-    /** `cwd`'s ancestor levels, shallowest-first, each flagged with whether a portable/portable-local file already exists there. */
-    readonly levels: readonly DirectoryLevelPresence[];
-    /** Every directory rule's own `path` field, exactly as written in `~/.agent-shim/directory-rules.json` (not yet normalised). */
-    readonly directoryRulePaths: readonly string[];
-    /** The identity's resolved active configuration profile — the tier-three fallback. */
-    readonly activeConfigProfile: string;
-}
-/**
- * Decides which file a `configure` toggle should be written into, in the exact three-tier precedence the README documents:
- *
- * 1. If `$PWD` is inside a directory covered by a committed `.agent-shim.json`, or a `.agent-shim.local.json` already exists there (even without a committed sibling), the toggle goes into `.agent-shim.local.json` in that same directory — the deepest such directory, when more than one ancestor qualifies.
- * 2. Otherwise, if an existing directory rule in the user's own `directory-rules.json` already applies to `$PWD` (its `path`, once resolved, is an ancestor of or equal to `$PWD`), the toggle is written into that rule — the most specific (longest-resolved-path) matching rule, when more than one applies.
- * 3. Otherwise, the toggle is written into the identity's own active configuration profile.
- *
- * Never touches a filesystem or a config file itself — every input is already gathered by the caller, which is what makes this function directly unit-testable with synthetic levels and rule paths.
- */
-export declare function chooseWriteTarget(params: ChooseWriteTargetParams): WriteTarget;
-/** Renders a `WriteTarget` as a short, human-readable description for `configure`'s own confirmation output. */
-export declare function describeWriteTarget(target: WriteTarget): string;
-/** Everything `runConfigure` needs beyond the identity/path the user typed. */
-export interface RunConfigureDeps {
-    readonly paths: LayoutPaths;
-    readonly prompts: PromptsPort;
-    readonly log: Pick<LogPort, "info">;
-}
-/** Inputs to `runConfigure` beyond its injected dependencies. */
-export interface RunConfigureParams {
-    readonly identityName: string;
-    /** A real `~/.claude`-relative path (never category-prefixed — that prefix is an entries-*key* convention, not a filesystem path). Given: entries mode. Omitted: categories mode. */
-    readonly path?: string;
-    readonly cwd: string;
-    readonly home: string;
-    readonly claudeHome: string;
-}
-/** Validates a candidate profile name for the wizard's text prompt: non-empty, matches the allowed shape, and (only when `existingNames` is given) not already taken. */
-export declare function validateProfileName(value: string, existingNames?: readonly string[]): string | undefined;
-/**
- * Inputs to `runProfileWizard` beyond the injected prompt/log ports. Split out so the launch path (which only has a `LayoutPaths`, not a full `ConfigureContext`) can call the wizard too.
- *
- * A discriminated union over three modes:
- * - `{ existingName }`: edit an existing profile's categories.
- * - `{ createName }`: create a new profile with this exact name (no name prompt), then choose categories. Used by the launch path, where the name is already decided.
- * - `{ defaultNewName? }`: create a new profile, prompting for a name first (with an optional pre-filled default). Used by the manual commands.
- */
-export type RunProfileWizardParams = {
-    readonly paths: LayoutPaths;
-    readonly existingName: string;
-} | {
-    readonly paths: LayoutPaths;
-    readonly createName: string;
-} | {
-    readonly paths: LayoutPaths;
-    readonly defaultNewName?: string;
-};
-/** What `runProfileWizard` produced. */
-export interface ProfileWizardResult {
-    readonly name: string;
-    readonly created: boolean;
-}
-/**
- * The unified create-or-edit flow for a configuration profile: one guided prompt sequence covering both cases that would otherwise split across a bare `profile add` (empty, no categories) and `configure`'s "edit a profile directly" branch (categories only, profile must already exist).
- *
- * Given an `existingName`: edits that profile's categories in place via a multiselect, seeded from its current values. Given a `createName`: creates the empty file with that exact name, no name prompt, then runs the category multiselect. Given neither: prompts for a name first (validated against the allowed shape and against every existing profile name), creates the empty file, then runs the same multiselect. Either way, a cancel at any prompt writes nothing and returns `undefined` — the caller decides what to do (e.g. the launch path proceeds without the profile, the manual command just stops).
- *
- * Driven entirely by the injected `PromptsPort` so the whole flow is unit-testable with a scripted sequence of answers, the same way `runConfigure` already is.
- */
-export declare function runProfileWizard(prompts: PromptsPort, params: RunProfileWizardParams): Promise<ProfileWizardResult | undefined>;
-/**
- * Runs `agent-shim configure [path] --identity <name>`'s interactive flow.
- *
- * Two modes, exactly per the README's "agent-shim configure: which file it writes to" section:
- *
- * - No `path`: shows the identity's resolved top-level categories (the only mode that ever touches categories), plus an option to edit a named configuration profile's own stored values directly instead.
- * - Given a `path` (a real `~/.claude`-relative path, never category-prefixed): shows that path's direct children with their resolved sharing state, for fine-grained entries overrides. Never shows or edits categories.
- *
- * Every actual toggle (in either mode, other than the "edit a profile directly" branch, which is an explicit target the user chose) is written via `chooseWriteTarget`'s three-tier precedence.
- */
-export declare function runConfigure(deps: RunConfigureDeps, params: RunConfigureParams): Promise<void>;
-/** Registers `agent-shim configure [path] [--identity <name>]` onto `program`. */
-export declare function registerConfigureCommand(program: Command, deps: CommandDeps): void;
-export {};

package/dist/types/credential.d.ts

@@ -1,136 +0,0 @@
-import type { Credential, CredentialSource, CredentialTarget, CredentialTargetVar } from "./config/schema";
-import { type CredentialCachePort } from "./credentialCache";
-/** The exit status for a launch whose selected provider or identity has a credential block none of whose sources yields a token: 64, the conventional `EX_USAGE`, because the invocation asked for a credential the environment cannot supply. */
-export declare const CREDENTIAL_UNAVAILABLE_EXIT = 64;
-/** How long a non-interactive credential command may run. Secret-store CLIs answer from a local cache or agent well within a second, so this leaves a wide margin while still failing a wedged command quickly instead of stalling the launch. */
-export declare const CREDENTIAL_COMMAND_TIMEOUT_MS = 10000;
-/** How long an interactive credential command may run: long enough for a person to notice and approve a biometric or password prompt, short enough that a prompt nobody is watching fails the launch rather than hanging it. */
-export declare const CREDENTIAL_INTERACTIVE_TIMEOUT_MS = 120000;
-/** What reading one `file` source found: nothing at that path, or its contents and permission bits. `mode` is undefined on a platform with no POSIX permission bits (Windows), where the looseness check cannot apply. */
-type SecretFileRead = {
-    readonly found: false;
-} | {
-    readonly found: true;
-    readonly content: string;
-    readonly mode: number | undefined;
-};
-/** The outcome of one credential command. `stderr` is empty for an interactive run, whose stderr goes to the terminal so a person sees any prompt. */
-export interface CredentialCommandResult {
-    readonly status: number | null;
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly timedOut: boolean;
-}
-/**
- * Everything resolving a credential needs from the outside world, injected so the resolver (and every launcher test) runs without `op`, the Keychain, real secret files or a terminal. `src/realPorts.ts` wires the real one; tests wire a fake.
- */
-export interface CredentialPort {
-    /** Reads a `file` source's path (absolute or `~`-rooted). */
-    readonly readSecretFile: (filePath: string) => SecretFileRead;
-    /** Runs a command source's argv directly (no shell) under a timeout, capturing stdout. An interactive run inherits the terminal's stdin and stderr so a person can answer a prompt. */
-    readonly runCommand: (argv: readonly [string, ...string[]], options: {
-        readonly timeoutMs: number;
-        readonly interactive: boolean;
-    }) => CredentialCommandResult;
-    /** Whether a person can answer a prompt now: standard input is a terminal, or there is a desktop session to show a dialog in. */
-    readonly personPresent: () => boolean;
-    /** Where cached credentials live, used only for a credential block that asks for caching. Omit to resolve every launch from the sources. */
-    readonly cache?: CredentialCacheEnv;
-}
-/** The sources that run a command: `command` itself and the two presets that compile to one. */
-type CommandBackedSource = Extract<CredentialSource, {
-    readonly command: unknown;
-} | {
-    readonly op: unknown;
-} | {
-    readonly keychain: unknown;
-}>;
-/**
- * The argv a command-backed source runs, with the `op` and `keychain` presets compiled to theirs: `op read <ref>` and `security find-generic-password -s <service> [-a <account>] -w`.
- */
-export declare function commandArgv(source: CommandBackedSource): readonly [string, ...string[]];
-/**
- * Whether a source needs a person present. An explicit `interactive` always wins. Otherwise only `op` defaults to interactive, because the desktop app's integration asks for approval, unless `OP_SERVICE_ACCOUNT_TOKEN` is set, in which case `op` authenticates as the service account with nobody asked. A plain `command` and a `keychain` read default to non-interactive: a Keychain item whose access list already trusts `security` reads silently, and one that does not fails at once with "User interaction is not allowed" rather than hanging.
- */
-export declare function isInteractiveSource(source: CredentialSource, env: Readonly<Record<string, string | undefined>>): boolean;
-/** One source as `check`, `doctor` and every `--json` output report it: its kind plus the same non-secret identifying detail `describeSource` prints. */
-type CredentialSourceSummary = {
-    readonly kind: "env";
-    readonly variable: string;
-} | {
-    readonly kind: "file";
-    readonly path: string;
-} | {
-    readonly kind: "command";
-    readonly program: string;
-} | {
-    readonly kind: "op";
-    readonly reference: string;
-} | {
-    readonly kind: "keychain";
-    readonly service: string;
-    readonly account?: string;
-} | {
-    readonly kind: "literal";
-};
-/** A credential block as it is reported: its effective target and each source's summary, in order. */
-export interface CredentialSummary {
-    readonly target: CredentialTarget;
-    readonly sources: readonly CredentialSourceSummary[];
-    /** The block's cache setting when it asks for caching: how long a token is kept (absent for no expiry) and where. */
-    readonly cache?: {
-        readonly ttl?: string;
-        readonly store?: string;
-    };
-}
-/** Summarises a credential block for reporting, with `target` resolved to its default. */
-export declare function summariseCredential(credential: Credential): CredentialSummary;
-/** Renders a source for a message, as `formatSourceSummary` does its summary. */
-export declare function describeSource(source: CredentialSource): string;
-/** Renders a credential summary on one line for human-readable output: `bearer from env Z_API_TOKEN, then op op://...`. */
-export declare function formatCredentialSummary(summary: CredentialSummary): string;
-/** Renders a credential block on one line, as `formatCredentialSummary` does its summary. */
-export declare function describeCredential(credential: Credential): string;
-/** Inputs to `resolveCredential`. */
-export interface ResolveCredentialParams {
-    readonly credential: Credential;
-    /** The launching environment: where `env` sources are read, and what decides whether `op` is interactive. */
-    readonly env: Readonly<Record<string, string | undefined>>;
-    readonly port: CredentialPort;
-    /** What the credential belongs to, for messages and as its cache key: `provider z` or `identity work`. */
-    readonly subject: string;
-    /** True to skip a cached token and fetch from the sources, replacing the cached copy: what `credential warm` does. */
-    readonly refresh?: boolean;
-}
-/** What caching a credential needs beyond the block's own `cache` setting: the port holding entries, the platform that picks the default store, and the clock the TTL is measured on. */
-export interface CredentialCacheEnv {
-    readonly port: CredentialCachePort;
-    readonly platform: NodeJS.Platform;
-    readonly now: () => number;
-}
-/** A resolved credential: the token, where it goes, and which source produced it. `warnings` carries any source refused on the way for a reason worth reporting (a secret file with loose permissions). */
-export interface ResolvedCredential {
-    readonly target: CredentialTarget;
-    readonly token: string;
-    readonly source: CredentialSource;
-    readonly warnings: readonly string[];
-    /** When the token was fetched, if it came from the cache rather than a source; undefined for a live fetch. */
-    readonly cachedAt?: number;
-}
-/** The outcome of `resolveCredential`: a resolved credential, or a message naming every source and why none yielded a token. */
-export type CredentialResolution = {
-    readonly ok: true;
-    readonly credential: ResolvedCredential;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-/**
- * Resolves a credential block: a fresh cached token if the block caches one, else tries each source in order and returns the first non-empty token, with the block's target, storing it when the block caches. When none yields one, the message names every source and why, and never a value; for a caching block it also names the command that fills the cache from a terminal. Pure over its injected ports.
- */
-export declare function resolveCredential(params: ResolveCredentialParams): CredentialResolution;
-/**
- * The credential variables a child environment gets for a resolved token: the target's variable set to the token, and the other two set to undefined so that merging this over an environment removes them, and an ambient one inherited from the parent can neither outrank nor sit alongside the credential agent-shim chose. Removing a variable (rather than setting it to the empty string) leaves nothing for Claude Code to interpret.
- */
-export declare function credentialVariables(target: CredentialTarget, token: string): Record<CredentialTargetVar, string | undefined>;
-export {};

package/dist/types/credentialCache.d.ts

@@ -1,46 +0,0 @@
-import { z } from "zod";
-import { type CredentialCache, type CredentialCacheStore } from "./config/schema";
-/** What a cache stores for one credential: the token, when it was fetched, and the source that produced it (a non-secret descriptor, kept so `check` and the launch log can still say where the token came from). */
-export declare const CachedCredentialSchema: z.ZodObject<{
-    token: z.ZodString;
-    fetchedAt: z.ZodNumber;
-    source: z.ZodUnion<readonly [z.ZodObject<{
-        env: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        file: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        interactive: z.ZodOptional<z.ZodBoolean>;
-        timeoutMs: z.ZodOptional<z.ZodInt>;
-        command: z.ZodTuple<[z.ZodString], z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        interactive: z.ZodOptional<z.ZodBoolean>;
-        timeoutMs: z.ZodOptional<z.ZodInt>;
-        op: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        interactive: z.ZodOptional<z.ZodBoolean>;
-        timeoutMs: z.ZodOptional<z.ZodInt>;
-        keychain: z.ZodObject<{
-            service: z.ZodString;
-            account: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-    }, z.core.$strict>, z.ZodObject<{
-        literal: z.ZodString;
-    }, z.core.$strict>]>;
-}, z.core.$strict>;
-export type CachedCredential = z.infer<typeof CachedCredentialSchema>;
-/**
- * Where cached credentials live, injected so resolution and its tests need neither the Keychain nor a real directory. `owner` names what the credential belongs to (`identity work`, `provider z`) and is the entry's key; `store` picks the backing store. `read` returns undefined for a missing or unreadable entry, since an entry that cannot be used is the same as no entry.
- */
-export interface CredentialCachePort {
-    readonly read: (store: CredentialCacheStore, owner: string) => CachedCredential | undefined;
-    readonly write: (store: CredentialCacheStore, owner: string, entry: CachedCredential) => void;
-    readonly remove: (store: CredentialCacheStore, owner: string) => void;
-}
-/** The store a block uses: its own choice, else the Keychain on macOS and a file elsewhere. */
-export declare function effectiveStore(cache: Readonly<CredentialCache>, platform: NodeJS.Platform): CredentialCacheStore;
-/** A `ttl` such as `12h` in milliseconds, or undefined for no expiry. */
-export declare function ttlMs(cache: Readonly<CredentialCache>): number | undefined;
-/** Whether a cached entry is still within its TTL at `now`. A cache with no TTL never expires; an entry stamped in the future (a clock that moved back) is treated as expired. */
-export declare function isFresh(entry: CachedCredential, cache: Readonly<CredentialCache>, now: number): boolean;
-/** How old a cached entry is, for `check` and `doctor` to report without the value. */
-export declare function cacheAgeMs(entry: CachedCredential, now: number): number;

package/dist/types/directoryRulesStore.d.ts

@@ -1,43 +0,0 @@
-import { type DirectoryRule, type DirectoryRules } from "./config/schema";
-import { CliError } from "./cliError";
-import type { LayoutPaths } from "./paths";
-/** Raised by `removeDirectoryRule`, `updateDirectoryRule` and `rule show` when no rule matches the given path exactly. */
-export declare class DirectoryRuleNotFoundError extends CliError {
-    readonly rulePath: string;
-    constructor(rulePath: string);
-}
-/** Raised by `addDirectoryRule` when neither `--config-profile` nor `--identity` is given, and by `updateDirectoryRule` when an update would leave a rule that sets nothing at all: a rule that pins and overrides nothing would do nothing. */
-export declare class DirectoryRuleMissingTargetError extends CliError {
-    constructor();
-}
-/** Raised by `addDirectoryRule` when a rule for the exact path already exists: `rule add` creates, `rule set` updates. */
-export declare class DirectoryRuleAlreadyExistsError extends CliError {
-    readonly rulePath: string;
-    constructor(rulePath: string);
-}
-/** Reads `~/.agent-shim/directory-rules.json`, or an empty rule set when the file does not exist yet. */
-export declare function readDirectoryRules(paths: LayoutPaths): DirectoryRules;
-/** Validates and writes the whole `~/.agent-shim/directory-rules.json` file. Exported so `src/configure.ts` can update a single rule's `categories`/`entries` in place without duplicating this validate-then-write step. Throws `ConfigValidationError` when `rules` fails `DirectoryRulesSchema`, rather than letting the underlying `ZodError` escape as an unhandled crash. */
-export declare function writeDirectoryRules(paths: LayoutPaths, rules: DirectoryRules): void;
-/** Lists every directory rule, in file order. */
-export declare function listDirectoryRules(paths: LayoutPaths): readonly DirectoryRule[];
-/** Inputs to `addDirectoryRule` beyond the path itself. */
-export interface AddDirectoryRuleOptions {
-    readonly configProfile?: string;
-    readonly identity?: string;
-}
-/**
- * Adds a new directory rule for `rulePath`. Throws `DirectoryRuleAlreadyExistsError` when a rule for that exact path already exists (`updateDirectoryRule` changes one), and `DirectoryRuleMissingTargetError` when neither `configProfile` nor `identity` is given, since a rule that pins neither would do nothing.
- */
-export declare function addDirectoryRule(paths: LayoutPaths, rulePath: string, options: AddDirectoryRuleOptions): DirectoryRule;
-/** The fields `updateDirectoryRule` changes. A value of `false` removes that field from the rule. */
-export interface UpdateDirectoryRuleOptions {
-    readonly configProfile?: string | false;
-    readonly identity?: string | false;
-}
-/**
- * Updates the existing directory rule for `rulePath` in place, keeping its position in the file and every field not named. Throws `DirectoryRuleNotFoundError` when no rule matches that exact path, and `DirectoryRuleMissingTargetError` when the update would leave a rule that does nothing (remove it with `removeDirectoryRule` instead).
- */
-export declare function updateDirectoryRule(paths: LayoutPaths, rulePath: string, options: UpdateDirectoryRuleOptions): DirectoryRule;
-/** Removes the directory rule for `rulePath`. Throws `DirectoryRuleNotFoundError` when no rule matches that exact path. */
-export declare function removeDirectoryRule(paths: LayoutPaths, rulePath: string): void;

package/dist/types/doctorReport.d.ts

@@ -1,117 +0,0 @@
-import { type ClaudeShimState, type PathShadowStatus } from "./claudeShim";
-import type { LayoutPaths } from "./paths";
-import type { RunPort } from "./launcher/ports";
-import type { DiscoveredClaudeBinary } from "./versionDiscovery";
-type DoctorSeverity = "pass" | "warn" | "fail";
-type DoctorSection = "ambient-credential" | "binary-discovery" | "claude-shim" | "path-resolution" | "legacy-name" | "config-profile" | "identity" | "pool" | "provider" | "keychain" | "directory-rules" | "global-config" | "categories-local" | "active-identity" | "headroom";
-/** One line of `agent-shim doctor`'s report. `subject` names the identity/profile/rule the finding is about, when the section has more than one of those. */
-interface DoctorFinding {
-    readonly section: DoctorSection;
-    readonly subject?: string;
-    readonly severity: DoctorSeverity;
-    readonly message: string;
-}
-/** The full result of `runDoctor`. `ok` is false iff any finding is a `fail` — a `warn` never fails the report on its own. */
-export interface DoctorReport {
-    readonly findings: readonly DoctorFinding[];
-    readonly ok: boolean;
-}
-/** One identity's raw `identity.json`, unparsed — `runDoctor` does its own JSON.parse/schema validation so one malformed file never aborts the rest of the report. */
-export interface DoctorIdentityInput {
-    readonly name: string;
-    readonly path: string;
-    readonly raw: string | undefined;
-    /** The identity's own farm root (`identitiesDir/<name>`) — the account name the Keychain lookup uses. */
-    readonly farmRoot: string;
-}
-/** One configuration profile's raw `<name>.json`, unparsed. */
-export interface DoctorConfigProfileInput {
-    readonly name: string;
-    readonly path: string;
-    readonly raw: string | undefined;
-}
-/** One provider's raw `<name>.json`, unparsed. */
-export interface DoctorProviderInput {
-    readonly name: string;
-    readonly path: string;
-    readonly raw: string | undefined;
-}
-/** A single optional top-level file `runDoctor` validates against a schema when present — absent is a legitimate, unconfigured state, not a failure. */
-interface DoctorFileInput {
-    readonly path: string;
-    readonly raw: string | undefined;
-}
-/** The outcome of resolving the real Claude Code binary, pre-resolved by the wiring layer since `discoverClaudeBinary` is not itself a parse-shaped pure operation and already has its own dedicated test coverage. */
-type DoctorBinaryDiscovery = {
-    readonly ok: true;
-    readonly binary: DiscoveredClaudeBinary;
-} | {
-    readonly ok: false;
-    readonly message: string;
-};
-/**
- * Where a bare command name resolves for the two names this tool owns.
- *
- * `ownExecutablePath` is this process's own PATH-visible location (`realOwnExecutablePath()`); `agentShim` is `findPathShadow`'s verdict for a bare `agent-shim` against the directory that executable lives in. `claude` is only populated when a shim is actually enabled — without one, a `claude` on PATH is Claude Code's own binary, which is not a shadow of anything.
- */
-interface DoctorPathResolution {
-    readonly ownExecutablePath: string;
-    readonly agentShim: PathShadowStatus;
-    readonly claude?: PathShadowStatus;
-}
-/**
- * Collapses a `shadowed` verdict back to `ok` when the shadowing entry and this executable are literally the same file reached by two names — `findPathShadow` compares *directories*, so a symlink on PATH pointing at the running executable's own real location otherwise reads as a shadow of itself.
- *
- * `realpath` must resolve symlinks, and must return its argument unchanged rather than throwing when the path cannot be resolved (a broken symlink, a race with an uninstall), so an unresolvable path simply stays unequal and the shadow verdict stands.
- */
-export declare function refinePathShadow(status: PathShadowStatus, ownExecutablePath: string, realpath: (target: string) => string): PathShadowStatus;
-/** Everything `runDoctor` needs, all of it already loaded/injected — nothing in `runDoctor` itself reads a file, shells out, or touches the farm. */
-export interface RunDoctorParams {
-    readonly env: Readonly<Record<string, string | undefined>>;
-    readonly identities: readonly DoctorIdentityInput[];
-    readonly configProfiles: readonly DoctorConfigProfileInput[];
-    readonly providers: readonly DoctorProviderInput[];
-    readonly directoryRules: DoctorFileInput;
-    readonly globalConfig: DoctorFileInput;
-    readonly categoriesLocal: DoctorFileInput;
-    readonly activeIdentity: DoctorFileInput;
-    readonly binaryDiscovery: DoctorBinaryDiscovery;
-    /** Whether `agent-shim shim enable` has been run, and whether its recorded target still exists on disk — pre-resolved by the wiring layer, since checking a file's existence is real I/O, not a parse-shaped pure operation. */
-    readonly claudeShim: {
-        readonly state: ClaudeShimState | undefined;
-        readonly targetExists: boolean;
-    };
-    /** Which executables a bare `agent-shim` (and, when the shim is enabled, a bare `claude`) would actually run — pre-resolved by the wiring layer, since scanning PATH is real I/O. */
-    readonly pathResolution: DoctorPathResolution;
-    /** The resolved state root (`paths.root`), whose directory name says whether this installation still lives under the former `.claude-use` name. */
-    readonly rootPath: string;
-    /** Runs `security find-generic-password` for the per-identity Keychain check. Omit to skip that check entirely (e.g. off macOS). */
-    readonly run?: RunPort;
-    /** `process.platform` in real use; the Keychain check only ever runs when this is `"darwin"`. */
-    readonly platform: string;
-    /** The headroom daemon's state.json plus a zombie-aware liveness predicate for the pids it names (a defunct daemon holds no port but still answers signal 0). Omit the raw text when the daemon has never run; that is a pass, not a failure. */
-    readonly headroom: {
-        readonly state: DoctorFileInput;
-        readonly isRunning: (pid: number) => boolean;
-    };
-}
-/**
- * Audits the whole `~/.agent-shim` config graph for internal consistency: every identity, every configuration profile's own `extends` chain, every provider, `directory-rules.json`, `config.json`, `categories.local.json`, `active-identity`, plus real Claude Code binary discoverability and ambient-credential exposure.
- *
- * Deliberately identity/directory-agnostic, unlike `runCheck` — there is no single cascade to resolve `doctor` against, so it never touches settings-exposure (which only means anything relative to one resolved cascade).
- *
- * Every check aggregates rather than throws: a malformed file becomes one `fail` finding for that file, not an aborted report. This is the one place in the codebase that deliberately breaks the "throw a validation error and let it propagate" convention every other command relies on — `doctor`'s whole purpose is to survive a broken file and keep auditing everything else.
- */
-export declare function runDoctor(params: RunDoctorParams): DoctorReport;
-/** Renders a full `DoctorReport` as plain text lines, one section header at a time, in the order `agent-shim doctor` prints them. */
-export declare function formatDoctorReport(report: DoctorReport): string[];
-/** What `collectDoctorReport` needs from its caller. */
-export interface CollectDoctorReportParams {
-    readonly paths: LayoutPaths;
-    readonly env: NodeJS.ProcessEnv;
-}
-/**
- * Audits the whole state root against this machine: the edge adapter that enumerates every identity, configuration profile and provider on disk, reads every top-level config file as raw text (never pre-parsing, so one malformed file cannot abort the report), discovers the real Claude Code binary and resolves where a bare command name runs from, and hands the facts to the pure `runDoctor`.
- */
-export declare function collectDoctorReport(params: CollectDoctorReportParams): DoctorReport;
-export {};