#CLI 与库包入口

import { 
const defineConfig: (config: AgentBundleConfig | ConfigFactory) => AgentBundleConfig | ConfigFactorydefineConfig } from 'agent-bundle/config';

export default 
function defineConfig(config: AgentBundleConfig | ConfigFactory): AgentBundleConfig | ConfigFactorydefineConfig({
  
AgentBundleConfig.bin?: AgentBundleBinConfig | undefinedbin: { 'my-plugin': './src/cli.ts' },
  
AgentBundleConfig.lib?: AgentBundleLibConfig | undefinedlib: { 
AgentBundleLibEntry.dts?: boolean | undefined
Emit type declarations next to the library output — Rslib's bundleless
dts mode, a .d.ts graph beside the bundle rather than one rolled-up
file. Defaults to true.dts: true, 
AgentBundleLibEntry.entry: stringentry: './src/index.ts' },
  
AgentBundleConfig.output?: AgentBundleOutputConfig | undefinedoutput: { 
AgentBundleOutputConfig.distPath?: string | undefined
The artifact output directory of agent-bundle build, relative to the
project root. Defaults to dist. The per-invocation CLI --output flag
still wins, but remains subject to the same project-root containment
check; absolute and external output paths are unsupported.distPath: 'artifact' },
  
AgentBundleConfig.plugin: AgentBundlePluginConfigplugin: { 
AgentBundlePluginConfig.description?: string | undefineddescription: 'A CLI plus a plugin.', 
AgentBundlePluginConfig.name: stringname: 'my-plugin' },
  
AgentBundleConfig.targets?: string[] | undefinedtargets: ['portable', 'claude'],
});

// src/cli.ts — the whole CLI entry a consumer writes
import type { ExecutableMainContext } from 'agent-bundle';

export const main = async (
  argv: readonly string[],
  { terminal }: ExecutableMainContext,
): Promise<number> => {
  if (terminal.stderr.color !== 'none') { /* 在 stderr 上绘制进度 */ }
  return 0;
};

// src/cli/inspect.ts — the whole command a consumer writes
import type { CliRouteConfig, 
interface CliRouteProps<InputSchema extends RouteSchema>
Props received by every routed CLI command's default function.
Read transport-owned invocation, host, session, actor, and workspace axes
with await agent() from @agent-bundle/runtime. Every identity axis is
Observed; unavailable axes carry a typed reason, and parsed command input
cannot override request identity.CliRouteProps } from 'agent-bundle';
import { 
import zz } from 'zod';

export const 
const config: {
    description: string;
    positionals: string[];
    inputJsonSchema: {
        type: "object";
        additionalProperties: false;
        properties: {
            maxFiles: {
                type: "number";
            };
            root: {
                type: "string";
            };
        };
        required: string[];
    };
}
config = {
  
CliRouteConfig.description?: string | undefineddescription: 'Inspect a bounded source tree without changing it.',
  
CliRouteConfig.positionals?: readonly string[] | undefined
The inputSchema keys consumed as bare arguments, in order. All but the
last must be scalar; a trailing z.array(...) key is variadic. Keys not
named here become --options.positionals: ['root'],
  
CliRouteConfig.inputJsonSchema?: RouteInputSchema | undefined
Execution-free input metadata for forms and CLI flags; the original schema owns validation.inputJsonSchema: {
    
RouteInputSchema.type: "object"type: 'object',
    
RouteInputSchema.additionalProperties: falseadditionalProperties: false,
    
RouteInputSchema.properties: Readonly<Record<string, RouteInputPropertySchema>>properties: { 
maxFiles: {
    type: "number";
}
maxFiles: { 
RouteInputNumberSchema.type: "number"type: 'number' }, 
root: {
    type: "string";
}
root: { 
RouteInputStringSchema.type: "string"type: 'string' } },
    
RouteInputSchema.required?: readonly string[] | undefinedrequired: ['root'],
  },
} satisfies CliRouteConfig;

export const 
const inputSchema: z.ZodObject<{
    maxFiles: z.ZodOptional<z.ZodNumber>;
    root: z.ZodString;
}, z.core.$strict>
inputSchema = 
import zz.
function object<{
    maxFiles: z.ZodOptional<z.ZodNumber>;
    root: z.ZodString;
}>(shape?: {
    maxFiles: z.ZodOptional<z.ZodNumber>;
    root: z.ZodString;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueInvalidType<unknown> | z.core.$ZodIssueUnrecognizedKeys>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    maxFiles: z.ZodOptional<z.ZodNumber>;
    root: z.ZodString;
}, z.core.$strip>
object({
  
maxFiles: z.ZodOptional<z.ZodNumber>maxFiles: 
import zz.
function number(params?: string | z.core.$ZodNumberParams): z.ZodNumbernumber().
_ZodNumber<$ZodNumberInternals<number>>.int(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodNumber
Consider z.int() instead. This API is considered legacy; it will never be removed but a better alternative exists.int().
_ZodNumber<$ZodNumberInternals<number>>.min(value: number, params?: string | z.core.$ZodCheckGreaterThanParams): z.ZodNumbermin(1).
_ZodNumber<$ZodNumberInternals<number>>.max(value: number, params?: string | z.core.$ZodCheckLessThanParams): z.ZodNumbermax(256).
ZodType<any, any, $ZodNumberInternals<number>>.optional(): z.ZodOptional<z.ZodNumber>optional(),
  
root: z.ZodStringroot: 
import zz.
function string(params?: string | z.core.$ZodStringParams): z.ZodString (+1 overload)string().
_ZodString<$ZodStringInternals<string>>.min(minLength: number, params?: string | z.core.$ZodCheckMinLengthParams): z.ZodStringmin(1),
}).
ZodObject<{ maxFiles: ZodOptional<ZodNumber>; root: ZodString; }, $strip>.strict(): z.ZodObject<{
    maxFiles: z.ZodOptional<z.ZodNumber>;
    root: z.ZodString;
}, z.core.$strict>
Consider z.strictObject(A.shape) insteadstrict();

export const 
const resultSchema: z.ZodObject<{
    scanned: z.ZodNumber;
}, z.core.$strict>
resultSchema = 
import zz.
function object<{
    scanned: z.ZodNumber;
}>(shape?: {
    scanned: z.ZodNumber;
} | undefined, params?: string | {
    error?: string | z.core.$ZodErrorMap<NonNullable<z.core.$ZodIssueInvalidType<unknown> | z.core.$ZodIssueUnrecognizedKeys>> | undefined;
    message?: string | undefined | undefined;
} | undefined): z.ZodObject<{
    scanned: z.ZodNumber;
}, z.core.$strip>
object({ 
scanned: z.ZodNumberscanned: 
import zz.
function number(params?: string | z.core.$ZodNumberParams): z.ZodNumbernumber().
_ZodNumber<$ZodNumberInternals<number>>.int(params?: string | z.core.$ZodCheckNumberFormatParams): z.ZodNumber
Consider z.int() instead. This API is considered legacy; it will never be removed but a better alternative exists.int() }).
ZodObject<{ scanned: ZodNumber; }, $strip>.strict(): z.ZodObject<{
    scanned: z.ZodNumber;
}, z.core.$strict>
Consider z.strictObject(A.shape) insteadstrict();

export default async function 
function inspect({ input, signal }: CliRouteProps<typeof inputSchema>): Promise<{
    scanned: number;
}>
inspect(
  { 
input: {
    root: string;
    maxFiles?: number | undefined;
}
input, 
signal: AbortSignalsignal }: 
interface CliRouteProps<InputSchema extends RouteSchema>
Props received by every routed CLI command's default function.
Read transport-owned invocation, host, session, actor, and workspace axes
with await agent() from @agent-bundle/runtime. Every identity axis is
Observed; unavailable axes carry a typed reason, and parsed command input
cannot override request identity.CliRouteProps<typeof 
const inputSchema: z.ZodObject<{
    maxFiles: z.ZodOptional<z.ZodNumber>;
    root: z.ZodString;
}, z.core.$strict>
inputSchema>,
) {
  
signal: AbortSignalsignal.
AbortSignal.throwIfAborted(): void
The throwIfAborted() method throws the signal's abort reason if the signal has been aborted; otherwise it does nothing.
MDN ReferencethrowIfAborted();
  return { 
scanned: numberscanned: 
input: {
    root: string;
    maxFiles?: number | undefined;
}
input.
maxFiles?: number | undefinedmaxFiles ?? 0 };
}

import { defineTool } from 'agent-bundle/routes';

export default defineTool({
  inputJsonSchema: {
    type: 'object',
    additionalProperties: false,
    properties: {
      laneKey: { type: 'string' },
      limit: { type: 'number' },
    },
  },
  inputSchema,
  resultSchema,
}, handler);

// src/mcp/hauler/tools/hauler_status.cli.ts
import type { CliProjectionConfig } from 'agent-bundle/routes';
import type { inputSchema } from './hauler_status.js';

export const config = {
  command: ['status'],
  confirm: false,
  description:
    'Show the queue, in-flight cargo work, lanes, and admission state.',
  flags: {
    laneKey: {
      description: 'Only requests in this lane key',
      name: 'lane',
    },
    limit: { description: 'Recent rows to show' },
    statuses: {
      description: 'Only these statuses (repeatable)',
      name: 'status',
    },
    tickets: {
      description: 'Only these tickets (repeatable)',
      name: 'ticket',
    },
  },
} satisfies CliProjectionConfig<typeof inputSchema>;

// src/mcp/hauler/tools/hauler_request.cli.ts
import type { CliProjectionConfig } from 'agent-bundle/routes';
import type { z } from 'zod';

import { parseTicketList } from '../../../client/parse.js';
import type { inputSchema } from './hauler_request.js';

export const config = {
  command: ['request'],
  confirm: false,
  description:
    'Submit a background cargo request and print its ticket: ' +
    'hauler request [--after cc-N] -- cargo check -p foo',
  flags: {
    after: {
      description:
        'Tickets that must finish first (repeatable, or comma-separated)',
    },
    cwd: {
      description: 'Workspace directory (default: current directory)',
      required: false,
    },
    host: { description: 'Agent host name for attribution' },
    session: { description: 'Agent session id for attribution' },
  },
  positionals: ['argv'],
} satisfies CliProjectionConfig<typeof inputSchema>;

type CliInput = Omit<z.input<typeof inputSchema>, 'cwd' | 'after'> & {
  readonly after?: readonly string[];
  readonly cwd?: string;
};

export const mapInput = (
  input: CliInput,
): z.input<typeof inputSchema> => {
  const after = parseTicketList(input.after ?? []);
  return {
    ...input,
    cwd: input.cwd ?? process.cwd(),
    ...(after.length === 0 ? {} : { after }),
  };
};

import type { CliProjectionConfig } from 'agent-bundle/routes';

import type { inputSchema } from './convert_audiobook.js';

export const config = {
  command: ['convert'],
  confirm: false,
  description: 'Plan or apply a verified conversion to one chaptered M4B.',
  input: 'json',
} satisfies CliProjectionConfig<typeof inputSchema>;

import meta, { name, packageName, packageVersion, version } from 'agent-bundle/meta';

import { defineConfig, definePrebuilt } from 'agent-bundle';

export default defineConfig({
  payload: {
    tools: definePrebuilt({
      source: './built/tools',
      targets: ['claude'],
      runtimeDependencies: ['sharp'],
    }),
  },
});

tools: {
  rspack: (config, { rspack }) => {
    // `rspack` is always the executing engine's own object.
    return config;
  },
},