@wirecat/cli-core 0.448.0 → 0.450.0

package/dist/cli/preview.js

@@ -6,19 +6,21 @@ import { commandPathOf } from "./command-contract.js";
 import { refuseUnknownPermissionKeys } from "./permission-keys.js";
 export class PreviewComplete extends Error {
 }
-export const preview = (command, settings, tool, keyOf, messenger = true) => {
+export const preview = (command, settings, tool, keys, messenger = true) => {
     const path = commandPathOf(command);
     const { permissions } = settings;
-    refuseUnknownPermissionKeys(command, settings, tool, keyOf && ((one) => keyOf(commandPathOf(one))));
-    const key = keyOf?.(path) ?? keyForCommand(path);
-    const level = key ? levelFor(permissions, key).level : "allow";
-    for (const source of readKeysForCommand(path)) {
+    const declared = typeof keys === "object" ? keys : undefined;
+    const keyOf = typeof keys === "object" ? keys.keyOf : keys;
+    refuseUnknownPermissionKeys(command, settings, tool, declared ?? (keyOf && ((one) => keyOf(commandPathOf(one)))));
+    const key = declared ? declared.keyOf(path) : (keyOf?.(path) ?? keyForCommand(path));
+    const level = key ? levelFor(permissions, key, declared?.defaults).level : "allow";
+    for (const source of declared ? [] : readKeysForCommand(path)) {
         if (levelFor(permissions, source).level === "deny")
             throw new CliError("permission_error", `this profile does not permit ${source}`, { permission: source });
     }
     const meta = metaOf(command);
     const writes = (meta.effects !== undefined && writesAnything(meta.effects)) ||
-        (key !== null && key !== undefined && WRITE_KEYS.includes(key));
+        (!declared && key !== null && key !== undefined && WRITE_KEYS.includes(key));
     if (level === "deny" || (writes && level === "readonly"))
         throw new CliError("permission_error", `this profile does not permit ${path.join(" ")}`, { permission: key });
     return previewBody(command, { key: key ?? null, level }, messenger);

package/dist/cli/program.d.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import { type AppIdentity } from "../ports/app.js";
 import { type BaseEnvironment } from "./context.js";
 import { type FirstScreen } from "./help/first-screen.js";
+import type { CommandPermissions } from "./permission-keys.js";
 import { type GlobalFlags, type ResolveOptions, type Settings } from "./settings.js";
 export interface ProgramDefinition {
     app: AppIdentity;
@@ -10,6 +11,8 @@ export interface ProgramDefinition {
     /** The CLI's own settings, for keeping a failure that happened before its command could; plain ones without. */
     configuration?: {
         permissionKey?: (path: readonly string[]) => string | null | undefined;
+        /** A CLI's own keys (`commandPermissions`), from `settingsFor`: its commands are refused by them before they run. */
+        permissions?: CommandPermissions | undefined;
         resolveSettings: (flags?: GlobalFlags, options?: ResolveOptions) => Pick<Settings, "profile" | "keepFailedRuns" | "keepRunsForDays" | "skillHint"> & Partial<Pick<Settings, "recordInput" | "permissions" | "permissionSources" | "configPath" | "savedPermissions" | "sources">>;
     };
     configure?: (program: Command) => void;

package/dist/cli/program.js

@@ -17,7 +17,7 @@ import { logParsedArgv, logVersion } from "./argv-log.js";
 import { commandAvailability } from "./command-availability.js";
 import { commandPathOf } from "./command-contract.js";
 import { outputFor, provide } from "./context.js";
-import { refuseWriteBeforeConnecting } from "./early-refusal.js";
+import { refuseByCommandPermissions, refuseWriteBeforeConnecting } from "./early-refusal.js";
 import { changesAuthorityAt, changesAuthorityNow, isLogin, isStoreChange, judgedEffects, judgedTargets, storeChangeRefusal, } from "./effects.js";
 import { itemOf, renderAnswer, snakeKeys } from "./envelope.js";
 import { byteCount, DEFAULT_COMMAND_MS, DEFAULT_OUTPUT_BYTES, execution } from "./execution.js";
@@ -221,7 +221,7 @@ const runOnce = async (argv, definition, options) => {
                 });
                 if (!settings.permissions)
                     return undefined;
-                return commandAvailability(info, settings.permissions, definition.configuration?.permissionKey, changesAuthorityAt(program), readOnlyLockOf(definition.app, env) !== undefined, options.agent !== undefined);
+                return commandAvailability(info, settings.permissions, definition.configuration?.permissionKey ?? definition.configuration?.permissions?.keyOf, changesAuthorityAt(program), readOnlyLockOf(definition.app, env) !== undefined, options.agent !== undefined, definition.configuration?.permissions);
             }
             catch {
                 // Help must still work when the configuration needs repair.
@@ -296,6 +296,13 @@ const runOnce = async (argv, definition, options) => {
             dryRun: flags.dryRun === true,
             ...(definition.configuration ? { resolve: definition.configuration.resolveSettings } : {}),
         });
+        if (definition.configuration?.permissions)
+            refuseByCommandPermissions(action, definition.configuration.permissions, {
+                app: definition.app,
+                env: commandEnv,
+                dryRun: flags.dryRun === true,
+                resolve: definition.configuration.resolveSettings,
+            });
         // A client older than the relay's refusal to forward a login still sends one; on serve it would log out serve.
         if (options.relayed && isLogin(action))
             throw new CliError("permission_error", `\`${command} ${path.join(" ")}\` logs the account in or out, which serve never runs for a client — stop ` +
@@ -394,7 +401,7 @@ const runOnce = async (argv, definition, options) => {
                 configPath: resolved.configPath ?? "",
                 profile: resolved.profile,
                 ...(resolved.savedPermissions ? { savedPermissions: resolved.savedPermissions } : {}),
-            }, command, definition.configuration?.permissionKey, definition.app.messenger !== false);
+            }, command, definition.configuration?.permissionKey ?? definition.configuration?.permissions, definition.app.messenger !== false);
             renderAnswer(action, outputFor(action), itemOf(snakeKeys(previewed)));
             throw new PreviewComplete();
         }

package/dist/cli/settings.d.ts

@@ -4,6 +4,7 @@ import { type AISettings } from "../analysis/settings.js";
 import { type AppIdentity } from "../ports/app.js";
 import { type Level, type PermissionKey } from "../sends/permissions.js";
 import { type ConfigIssue } from "./config-issues.js";
+import type { CommandPermissions } from "./permission-keys.js";
 export declare const plain: (rule: string) => (issue: v.BaseIssue<unknown>) => string;
 export declare const count: v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>;
 export declare const flag: v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>;
@@ -24,6 +25,11 @@ export interface SettingsExtension<T extends object = Record<never, never>> {
     defaults?: v.ObjectEntries;
     /** Profiles this messenger keeps in files of its own, beyond the config file and the remembered accounts. */
     profiles?: (env: NodeJS.ProcessEnv) => string[];
+    /**
+     * A CLI that is not a messenger declares its own permission keys (`commandPermissions`): `permissions` and
+     * `--permission` then take any command path, which the program checks against its commands.
+     */
+    permissions?: CommandPermissions;
 }
 export interface SettingsExtensionContext {
     flags: GlobalFlags;
@@ -272,7 +278,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             record: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             record_input: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
-            permissions: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, (issue: v.RegexIssue<string>) => string>]>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
+            permissions: v.OptionalSchema<v.RecordSchema<v.GenericSchema<string>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 0, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
@@ -346,7 +352,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             record: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             record_input: v.OptionalSchema<v.BooleanSchema<(issue: v.BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
-            permissions: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, (issue: v.RegexIssue<string>) => string>]>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
+            permissions: v.OptionalSchema<v.RecordSchema<v.GenericSchema<string>, v.PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: v.PicklistIssue) => string>, (issue: v.BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 1, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<(issue: v.BaseIssue<unknown>) => string>, v.IntegerAction<number, (issue: v.BaseIssue<unknown>) => string>, v.MinValueAction<number, 0, (issue: v.BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: v.OptionalSchema<v.PicklistSchema<["auto", "messenger", "local"], (issue: v.BaseIssue<unknown>) => string>, undefined>;
@@ -364,6 +370,7 @@ export declare const settingsFor: <T extends object = Record<never, never>>(app:
             readonly profiles: v.OptionalSchema<v.RecordSchema<v.StringSchema<undefined>, v.StrictObjectSchema<v.ObjectEntries, (issue: v.StrictObjectIssue) => string>, "has to be an object of profiles, by name">, undefined>;
         }, (issue: v.StrictObjectIssue) => string>, undefined>;
     }, (issue: v.StrictObjectIssue) => string>;
+    permissions?: CommandPermissions | undefined;
 };
 /** What `settingsFor` hands a CLI — named, so a CLI can export it without naming the schema library's types. */
 export type Configuration = ReturnType<typeof settingsFor>;

package/dist/cli/settings.js

@@ -5,7 +5,7 @@ import { AI_ENTRIES, resolveAISettings } from "../analysis/settings.js";
 import { parseDuration } from "../domain/duration.js";
 import { DEFAULT_RERANK_MODEL, RERANK_MODELS } from "../embeddings/models.js";
 import { envName, readOnlyLockOf } from "../ports/app.js";
-import { assertOverridesTighten, CEILING_KEY, LEVELS, layerPermissions, permissionOverrides, RESOURCES, } from "../sends/permissions.js";
+import { assertOverridesTighten, CEILING_KEY, COMMAND_PATH_KEY, LEVELS, layerPermissions, permissionOverrides, RESOURCE_KEY, RESOURCES, } from "../sends/permissions.js";
 import { storePath } from "../store/path.js";
 import { sharedConfigPath } from "../store/shared-config.js";
 import { checkConfigText, issueMessage, readConfigFile, readConfigText, savedPermissionKeys, schemaIssues, settingPathOf, withoutPath, } from "./config-issues.js";
@@ -39,7 +39,9 @@ const wholeOrZero = (text, name) => {
         throw new CliError("validation_error", `${name} has to be a whole number, 0 or more`);
     return value;
 };
-const permissionLevels = v.record(v.pipe(v.string(), v.regex(new RegExp(`^(${RESOURCES.join("|")})(\\.[a-z][a-z-]*)*$`), (issue) => `${issue.input} is not a command path — it starts with one of ${RESOURCES.join(", ")}`)), v.picklist(LEVELS, (issue) => `has to be one of ${LEVELS.join(", ")}, not ${issue.received}`), plain('has to be an object of command paths and levels, like {"messages.delete": "ask"}'));
+const levelsOf = (key, example) => v.record(key, v.picklist(LEVELS, (issue) => `has to be one of ${LEVELS.join(", ")}, not ${issue.received}`), plain(`has to be an object of command paths and levels, like {"${example}": "ask"}`));
+const permissionLevels = levelsOf(v.pipe(v.string(), v.regex(RESOURCE_KEY, (issue) => `${issue.input} is not a command path — it starts with one of ${RESOURCES.join(", ")}`)), "messages.delete");
+const commandPathLevels = levelsOf(v.pipe(v.string(), v.regex(COMMAND_PATH_KEY, (issue) => `${issue.input} is not a command path, like api or events.delete`)), "events.delete");
 /** valibot's own words ("Expected never but received …") mean nothing to someone editing a file. */
 const objectMessage = (issue) => issue.expected === "never" ? "unknown setting" : "has to be an object, in braces";
 /**
@@ -122,7 +124,12 @@ export const fromFile = (settings, key, fallback) => first([
  * here; a command that re-derived the order would disagree with the others.
  */
 export const settingsFor = (app, extension = {}) => {
-    const profileEntries = { ...SHARED_PROFILE_ENTRIES, ...extension.profile };
+    const declared = extension.permissions;
+    const profileEntries = {
+        ...SHARED_PROFILE_ENTRIES,
+        ...(declared ? { permissions: v.optional(commandPathLevels) } : {}),
+        ...extension.profile,
+    };
     const defaultsOnly = { ...SHARED_DEFAULTS_ONLY, ...extension.defaults };
     const defaultsEntries = { ...profileEntries, ...defaultsOnly };
     const strictOf = (entries) => v.strictObject(entries, objectMessage);
@@ -252,8 +259,8 @@ export const settingsFor = (app, extension = {}) => {
             from,
             scope?.permissions,
         ]);
-        const overrides = permissionOverrides(flags.permission);
-        assertOverridesTighten(overrides, layerPermissions(fileLayers).levels);
+        const overrides = permissionOverrides(flags.permission, declared ? COMMAND_PATH_KEY : RESOURCE_KEY);
+        assertOverridesTighten(overrides, layerPermissions(fileLayers).levels, declared?.defaults);
         const permissions = withCeiling(layerPermissions([["flag", overrides], ...fileLayers]), env);
         const updateCheck = first([
             [
@@ -408,7 +415,15 @@ export const settingsFor = (app, extension = {}) => {
         saveConfigFile(path, checked.success ? checked.output : changed);
         return valueAt(checked.success ? checked.output : changed, at) ?? null;
     };
-    return { resolveSettings, configuredProfiles, changeSetting, allSettings, defaultsOnlyKeys, schema };
+    return {
+        resolveSettings,
+        configuredProfiles,
+        changeSetting,
+        allSettings,
+        defaultsOnlyKeys,
+        schema,
+        ...(declared ? { permissions: declared } : {}),
+    };
 };
 const isScope = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const valueAt = (node, path) => path.reduce((at, key) => (isScope(at) || Array.isArray(at) ? at[key] : undefined), node);

package/dist/cli/shared-command-exports.d.ts

@@ -81,7 +81,7 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
-            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -155,7 +155,7 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
-            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -173,8 +173,9 @@ export declare const configCommand: (app: import("./entry.js").AppIdentity, conf
             readonly profiles: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StrictObjectSchema<import("valibot").ObjectEntries, (issue: import("valibot").StrictObjectIssue) => string>, "has to be an object of profiles, by name">, undefined>;
         }, (issue: import("valibot").StrictObjectIssue) => string>, undefined>;
     }, (issue: import("valibot").StrictObjectIssue) => string>;
+    permissions?: import("./permission-keys.js").CommandPermissions | undefined;
 }, args_2?: {
-    permissionKey?: import("./permission-keys.js").PermissionKeyOf;
+    permissionKey?: import("./permission-keys.js").PermissionKeySource | undefined;
 } | undefined) => import("commander").Command;
 export declare const guideCommand: (app: Pick<import("./entry.js").AppIdentity, "command">, options: import("./guide.js").GuideOptions) => import("commander").Command;
 export declare const addMeetingBatchCommand: (program: import("commander").Command, deps: {
@@ -284,7 +285,7 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
-            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -358,7 +359,7 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             record: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             record_input: import("valibot").OptionalSchema<import("valibot").BooleanSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             keep_runs_for_days: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
-            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, (issue: import("valibot").RegexIssue<string>) => string>]>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
+            permissions: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").GenericSchema<string>, import("valibot").PicklistSchema<readonly ["deny", "readonly", "ask", "allow"], (issue: import("valibot").PicklistIssue) => string>, (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
             sends_per_hour: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 1, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             requests_per_minute: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<(issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").IntegerAction<number, (issue: import("valibot").BaseIssue<unknown>) => string>, import("valibot").MinValueAction<number, 0, (issue: import("valibot").BaseIssue<unknown>) => string>]>, undefined>;
             transcribe_with: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["auto", "messenger", "local"], (issue: import("valibot").BaseIssue<unknown>) => string>, undefined>;
@@ -376,6 +377,7 @@ export declare const completeCommand: (messenger: import("./index.js").Messenger
             readonly profiles: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").StringSchema<undefined>, import("valibot").StrictObjectSchema<import("valibot").ObjectEntries, (issue: import("valibot").StrictObjectIssue) => string>, "has to be an object of profiles, by name">, undefined>;
         }, (issue: import("valibot").StrictObjectIssue) => string>, undefined>;
     }, (issue: import("valibot").StrictObjectIssue) => string>;
+    permissions?: import("./permission-keys.js").CommandPermissions | undefined;
 }, "configuredProfiles">, options?: import("./messenger/complete-command.js").CompletionOptions | undefined) => import("commander").Command;
 export declare const contactsCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;
 export declare const conversationsCommand: (messenger: import("./index.js").Messenger) => import("commander").Command;

package/dist/http/public-url.d.ts

@@ -2,9 +2,13 @@
  * The tunnel's address a public listener is reached at, checked one way for every command that opens
  * one. `missing` says what needs it; `reaches` who calls through it, for the https refusal.
  */
-export declare const publicUrlOf: (given: string | undefined, { missing, reaches }: {
+export declare const publicUrlOf: (given: string | undefined, { missing, reaches, path, }: {
     missing: string;
     reaches: string;
+    /** An MCP server may sit under a path of a shared address, `https://<name>.ts.net/tg`, one per tool. */
+    path?: boolean;
 }) => URL;
 /** A local port from `--port`, or the command's own default. */
 export declare const portOf: (given: string | undefined, fallback: number) => number;
+/** The connector address under a public address: `https://<name>.ts.net/mcp`, or `…/tg/mcp` under a path. */
+export declare const mcpUrlOf: (publicUrl: URL) => URL;

package/dist/http/public-url.js

@@ -4,7 +4,7 @@ const EXAMPLE = "--public-url https://<name>.ts.net";
  * The tunnel's address a public listener is reached at, checked one way for every command that opens
  * one. `missing` says what needs it; `reaches` who calls through it, for the https refusal.
  */
-export const publicUrlOf = (given, { missing, reaches }) => {
+export const publicUrlOf = (given, { missing, reaches, path = false, }) => {
     if (!given)
         throw new CliError("configuration_error", `${missing} needs the tunnel's address: ${EXAMPLE}`);
     let url;
@@ -19,8 +19,14 @@ export const publicUrlOf = (given, { missing, reaches }) => {
     const local = url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname);
     if (url.protocol !== "https:" && !local)
         throw new CliError("validation_error", `--public-url must be https — ${reaches} through it`);
-    if (url.pathname !== "/" || url.search || url.hash)
-        throw new CliError("validation_error", `--public-url is the tunnel's address only, without a path: ${EXAMPLE}`);
+    if (url.search || url.hash || (!path && url.pathname !== "/"))
+        throw new CliError("validation_error", path
+            ? `--public-url is the tunnel's address, or a path of it, without a query: ${EXAMPLE}/tg`
+            : `--public-url is the tunnel's address only, without a path: ${EXAMPLE}`);
+    if (path && !/^(\/[A-Za-z0-9_-][A-Za-z0-9._-]*)*\/?$/.test(url.pathname))
+        throw new CliError("validation_error", "--public-url's path takes letters, digits, dot, dash and underscore: /tg");
+    if (path)
+        url.pathname = url.pathname.replace(/\/+$/, "") || "/";
     return url;
 };
 /** A local port from `--port`, or the command's own default. */
@@ -32,3 +38,5 @@ export const portOf = (given, fallback) => {
         throw new CliError("validation_error", "--port takes 1–65535");
     return port;
 };
+/** The connector address under a public address: `https://<name>.ts.net/mcp`, or `…/tg/mcp` under a path. */
+export const mcpUrlOf = (publicUrl) => new URL(`${publicUrl.pathname.replace(/\/+$/, "")}/mcp`, publicUrl.origin);

package/dist/mcp/agent.d.ts

@@ -2,6 +2,7 @@ import { type CommandInfo, type CommandOutput } from "@wirecat/cli-base/commands
 import { type ErrorObject } from "@wirecat/cli-base/standards";
 import * as v from "valibot";
 import { type CommandAvailability } from "../cli/command-availability.js";
+import type { CommandPermissions } from "../cli/permission-keys.js";
 export type { CommandAvailability } from "../cli/command-availability.js";
 import type { RunOptions } from "../cli/program.js";
 import type { StdinField } from "../cli/stdin-field.js";
@@ -22,6 +23,8 @@ export interface AgentContext {
     overrides?: readonly string[];
     /** The key a CLI's own command is checked against, when `keyForCommand` does not know it. */
     keyOf?: (path: readonly string[]) => PermissionKey | null | undefined;
+    /** A declared CLI's keys and defaults (`configuration.permissions`); in place of `keyOf`. */
+    permissions?: CommandPermissions | undefined;
     authority?: CatalogueOptions["authority"];
     /** The server's one open connection. The command borrows it: it cannot close it, and never opens its own. */
     connection?: () => Promise<MessengerAdapter>;
@@ -60,6 +63,8 @@ export interface CatalogueOptions {
     /** Whether a read-only lock currently blocks messenger changes. */
     readOnly?: boolean;
     keyOf?: (path: readonly string[]) => PermissionKey | null | undefined;
+    /** A declared CLI's keys and defaults (`configuration.permissions`); in place of `keyOf`. */
+    permissions?: CommandPermissions | undefined;
     /** Whether a command changes what a later run may do (`grantsAuthority`): execution requires `mcp.authority`. */
     authority?: (path: readonly string[]) => boolean;
     /** Arguments left out of every tool, by name. */

package/dist/mcp/agent.js

@@ -124,7 +124,7 @@ const schemaOf = (fields) => v.object(Object.fromEntries(fields.map((field) => [
 const startsWith = (path, prefix) => prefix.every((word, at) => path[at] === word);
 /** Build the discoverable command catalogue; profile permissions annotate availability. */
 export const toolsFromCommands = (commands, options = {}) => {
-    const { root = [], exclude = [], levels, keyOf, authority, readOnly = false } = options;
+    const { root = [], exclude = [], levels, keyOf, authority, readOnly = false, permissions } = options;
     return flatten(commands)
         .filter((info) => 
     // A group is offered only when it runs on its own; without an action it only prints its help.
@@ -136,9 +136,11 @@ export const toolsFromCommands = (commands, options = {}) => {
         info.lifetime === undefined &&
         (options.includeUnavailable === true ||
             (!(readOnly && (changesMessenger(info) || authority?.(info.path))) &&
-                (levels === undefined || commandAvailability(info, levels, keyOf, authority).available))))
+                (levels === undefined && !(readOnly && permissions)
+                    ? true
+                    : commandAvailability(info, levels ?? {}, keyOf, authority, readOnly, true, permissions).available))))
         .map((info) => ({
-        availability: () => commandAvailability(info, options.currentLevels?.() ?? levels ?? {}, keyOf, authority, readOnly),
+        availability: () => commandAvailability(info, options.currentLevels?.() ?? levels ?? {}, keyOf, authority, readOnly, true, permissions),
         command: info.path.slice(root.length).join(" "),
         path: info.path,
         title: info.summary ?? info.description,
@@ -189,7 +191,8 @@ export const runCommandForAgent = async (program, path, input, ctx) => {
         if (info.lifetime)
             throw new CliError("validation_error", `"${path.join(" ")}" runs until it is stopped; an agent call must return`);
         const levels = ctx.levels?.();
-        const availability = (levels || ctx.readOnly) && commandAvailability(info, levels ?? {}, ctx.keyOf, ctx.authority, ctx.readOnly);
+        const availability = (levels || ctx.readOnly || ctx.permissions) &&
+            commandAvailability(info, levels ?? {}, ctx.keyOf, ctx.authority, ctx.readOnly, true, ctx.permissions);
         if (availability && !availability.available)
             throw new CliError("permission_error", `${path.join(" ")}: ${availability.reason}`, {
                 sent: false,

package/dist/mcp/all-profiles.d.ts

@@ -0,0 +1,47 @@
+import type { Readable, Writable } from "node:stream";
+import { McpServer, type Tool } from "@modelcontextprotocol/server";
+import type { HttpOptions } from "./http/serve.js";
+export declare const CHILD_IDLE_MS: number;
+/** How to start the one-profile server for a profile: `<node> <script> <profile> mcp`. */
+export interface ChildSpec {
+    command: string;
+    args: string[];
+    env: NodeJS.ProcessEnv;
+}
+export interface AllProfilesOptions {
+    /** `tg`: the tools' prefix and the server's name. */
+    command: string;
+    version: string;
+    /** `Telegram`: what the `profile` field says it picks. */
+    name: string;
+    /** Read again for each new session, so a profile set up while serving over HTTP shows up. */
+    profiles: () => readonly string[];
+    child: (profile: string) => ChildSpec;
+    instructions: string;
+    idleMs?: number;
+    /** A child's stderr, line by line; never this process's stdout, which carries the protocol. */
+    note?: (line: string) => void;
+}
+/** The child's tool with the one field that picks the profile, required and without a default. */
+export declare const withProfile: (tool: Tool, profiles: readonly string[], name: string) => Tool;
+/**
+ * **One server for every profile of a tool** (TASK-26): `<tool> mcp` shows the tools `<tool> <profile> mcp` shows,
+ * each with a required `profile`, and runs a call in that profile's own server, started as a child the first time
+ * it is needed. The child applies the profile's permissions, keyring, store and audit log, so nothing here decides
+ * what a profile may do; this only routes.
+ */
+export declare const allProfilesServer: (options: AllProfilesOptions) => {
+    build: () => McpServer;
+    close: () => Promise<void>;
+};
+/** Over stdin and stdout until the client closes stdin or the process is told to stop; then the children close. */
+export declare const serveAllProfilesOverStdio: (options: AllProfilesOptions, io?: {
+    stdin?: Readable;
+    stdout?: Writable;
+    signal?: AbortSignal;
+}) => Promise<void>;
+/** Over HTTP behind the tunnel, one login for every profile; the caller keeps it running and closes it. */
+export declare const serveAllProfilesOverHttp: (options: AllProfilesOptions, http: Omit<HttpOptions, "appName" | "onError">) => Promise<{
+    url: URL;
+    close: () => Promise<void>;
+}>;