@p4code/cli 0.1.21 → 0.1.22

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$76 = () => {
 const layer$72 = Layer.sync(NetService, make$76);
 //#endregion
 //#region package.json
-var version = "0.1.21";
+var version = "0.1.22";
 //#endregion
 //#region src/config.ts
 /**
@@ -7858,11 +7858,21 @@ var ProjectWriteFileError = class extends Schema$1.TaggedErrorClass()("ProjectWr
 * is a URL as often as an id, and which tracker a bare `MOBILE-12262` belongs
 * to is a question only the resolver can answer.
 */
-const TicketResolveInput = Schema$1.Struct({ reference: TrimmedNonEmptyString });
+const TicketResolveInput = Schema$1.Struct({ reference: TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "The ticket as it was written: an identifier like MOBILE-12241, or a tracker URL. Pass it through verbatim rather than reformatting it." })) });
 const TicketResolveResult = Schema$1.Struct({
 	externalRef: TaskExternalRef,
 	/** The issue title as the tracker reports it, for the task that mirrors it. */
-	title: TrimmedNonEmptyString
+	title: TrimmedNonEmptyString,
+	/**
+	* The issue body, when the tracker reports one.
+	*
+	* Optional because it is the one field here that has a legitimate empty
+	* value - plenty of tickets are a title and nothing else - and because the
+	* composer, which only ever renders a chip, does not read it. It is carried
+	* for the caller that does: an agent handed a ticket id needs the
+	* requirements, and the title alone sends it back to ask for them.
+	*/
+	description: Schema$1.optional(TrimmedNonEmptyString)
 });
 /**
 * Why a reference could not be turned into a ticket.
@@ -34864,6 +34874,7 @@ const TASK_PLAN_TOOL_NAMES = /* @__PURE__ */ new Set([
 	"task_get",
 	"task_current",
 	"task_propose",
+	"ticket_resolve",
 	"taskcreate",
 	"taskupdate",
 	"tasklist",
@@ -36571,13 +36582,16 @@ const make$36 = Effect.gen(function* () {
 			reason: "not_found",
 			detail: `Linear returned nothing usable for ${identifier}.`
 		});
+		const externalRef = {
+			source: "linear",
+			identifier: stringField$1(issue, "identifier") ?? identifier,
+			url
+		};
+		const description = stringField$1(issue, "description");
 		return {
-			externalRef: {
-				source: "linear",
-				identifier: stringField$1(issue, "identifier") ?? identifier,
-				url
-			},
-			title
+			externalRef,
+			title,
+			...description === void 0 ? {} : { description }
 		};
 	}) };
 });
@@ -47727,6 +47741,18 @@ const ProviderEventLoggersLive = Layer.effect(ProviderEventLoggers, Effect.gen(f
 var ProviderService = class extends Context.Service()("@p4code/cli/provider/Services/ProviderService") {};
 //#endregion
 //#region src/mcp/McpProviderSession.ts
+/**
+* The name p4code declares its own toolkit under, in every provider.
+*
+* One constant because it is one name in the agent's world: prompts, skills and
+* the tool categories all say `p4-code`, whichever runtime is reading them.
+* Every adapter also excludes it from the user's registered servers, so a
+* registration of the same name cannot displace the built-in one and take the
+* per-thread credential's tools (`task_current`, `thread_*`) with it.
+*/
+const P4CODE_MCP_SERVER_NAME = "p4-code";
+/** The reserved names, as the set the mappers take. */
+const P4CODE_MCP_SERVER_NAMES = /* @__PURE__ */ new Set([P4CODE_MCP_SERVER_NAME]);
 const sessionsByThread = /* @__PURE__ */ new Map();
 function setMcpProviderSession(config) {
 	sessionsByThread.set(config.threadId, config);
@@ -71563,6 +71589,81 @@ const SERVER_NOTIFICATION_PARAMS = {
 	"account/login/completed": V2AccountLoginCompletedNotification
 };
 //#endregion
+//#region src/provider/Layers/codexMcpArgs.ts
+/** Codex's own name for the token variable of p4code's built-in server. */
+const CODEX_P4CODE_BEARER_TOKEN_ENV_VAR = "P4_MCP_BEARER_TOKEN";
+/** Prefix for the per-server variables the registered servers get. */
+const BEARER_TOKEN_ENV_VAR_PREFIX = "P4_MCP_BEARER_TOKEN_";
+/** TOML bare keys; anything else has to be quoted inside the dotted path. */
+const BARE_KEY = /^[A-Za-z0-9_-]+$/;
+const AUTHORIZATION_HEADER = "authorization";
+const BEARER_PREFIX = /^Bearer\s+/;
+const configKey = (name, field) => `mcp_servers.${BARE_KEY.test(name) ? name : JSON.stringify(name)}.${field}`;
+/**
+* A variable name derived from the server's, uniquely.
+*
+* Uppercased with every character a shell would not accept replaced, which can
+* collide (`a.b` and `a-b`), so the sanitized name is the prefix and the index
+* keeps it unique. The index is stable within one call, which is all that is
+* needed: the variable and the reference to it are emitted together.
+*/
+const bearerTokenEnvVar = (name, index) => `${BEARER_TOKEN_ENV_VAR_PREFIX}${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_${index}`;
+/**
+* @param resolved - Servers keyed by name, as the registry resolved them.
+* @param exclude - Names p4code declares itself. A registration cannot displace
+*   the built-in `p4-code` server, whose per-thread credential is the only
+*   thing that makes `task_current` and the thread tools work.
+*/
+const toCodexMcpConfig = (resolved, exclude = /* @__PURE__ */ new Set()) => {
+	const args = [];
+	const env = {};
+	const skipped = [];
+	const push = (name, field, value) => {
+		args.push("-c", `${configKey(name, field)}=${value}`);
+	};
+	let index = 0;
+	for (const [name, server] of Object.entries(resolved)) {
+		if (exclude.has(name)) continue;
+		if (server.type === "stdio") {
+			push(name, "command", JSON.stringify(server.command));
+			push(name, "args", JSON.stringify(server.args));
+			if (Object.keys(server.env).length > 0) push(name, "env", `{ ${Object.entries(server.env).map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`).join(", ")} }`);
+			index += 1;
+			continue;
+		}
+		if (server.type === "sse") {
+			skipped.push({
+				name,
+				reason: "Codex speaks streamable HTTP, not SSE."
+			});
+			continue;
+		}
+		const headerNames = Object.keys(server.headers);
+		const authorization = headerNames.find((key) => key.toLowerCase() === AUTHORIZATION_HEADER);
+		const otherHeaders = headerNames.filter((key) => key !== authorization);
+		if (otherHeaders.length > 0) {
+			skipped.push({
+				name,
+				reason: `Codex sends no custom headers, and this server needs ${otherHeaders.join(", ")}.`
+			});
+			continue;
+		}
+		push(name, "url", JSON.stringify(server.url));
+		if (authorization !== void 0) {
+			const token = server.headers[authorization]?.replace(BEARER_PREFIX, "") ?? "";
+			const variable = bearerTokenEnvVar(name, index);
+			env[variable] = token;
+			push(name, "bearer_token_env_var", JSON.stringify(variable));
+		}
+		index += 1;
+	}
+	return {
+		args,
+		env,
+		skipped
+	};
+};
+//#endregion
 //#region ../../packages/effect-codex-app-server/src/_internal/shared.ts
 const JsonRpcId$1 = Schema$1.Union([Schema$1.Number, Schema$1.String]);
 const JsonRpcError = Schema$1.Struct({
@@ -73959,6 +74060,11 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 		if (existing && !existing.stopped) yield* Effect.suspend(() => stopSessionInternal(existing));
 		const serviceTier = input.modelSelection?.instanceId === boundInstanceId ? getCodexServiceTierOptionValue(input.modelSelection) : void 0;
 		const mcpSession = readMcpProviderSession(input.threadId);
+		const externalMcp = toCodexMcpConfig(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, P4CODE_MCP_SERVER_NAMES);
+		for (const dropped of externalMcp.skipped) yield* Effect.logWarning("codex cannot express an mcp registration", {
+			server: dropped.name,
+			reason: dropped.reason
+		});
 		const runtimeInput = {
 			threadId: input.threadId,
 			providerInstanceId: boundInstanceId,
@@ -73971,17 +74077,18 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			runtimeMode: input.runtimeMode,
 			...input.modelSelection?.instanceId === boundInstanceId ? { model: input.modelSelection.model } : {},
 			...serviceTier ? { serviceTier } : {},
-			...mcpSession ? {
+			...externalMcp.args.length > 0 || mcpSession ? {
 				environment: {
 					...options?.environment ?? process.env,
-					P4_MCP_BEARER_TOKEN: mcpSession.authorizationHeader.replace(/^Bearer\s+/, "")
+					...externalMcp.env,
+					...mcpSession ? { [CODEX_P4CODE_BEARER_TOKEN_ENV_VAR]: mcpSession.authorizationHeader.replace(/^Bearer\s+/, "") } : {}
 				},
-				appServerArgs: [
+				appServerArgs: [...externalMcp.args, ...mcpSession ? [
 					"-c",
-					`mcp_servers.p4-code.url=${mcpSession.endpoint}`,
+					`mcp_servers.${P4CODE_MCP_SERVER_NAME}.url=${mcpSession.endpoint}`,
 					"-c",
-					"mcp_servers.p4-code.bearer_token_env_var=\"P4_MCP_BEARER_TOKEN\""
-				]
+					`mcp_servers.${P4CODE_MCP_SERVER_NAME}.bearer_token_env_var="${CODEX_P4CODE_BEARER_TOKEN_ENV_VAR}"`
+				] : []]
 			} : {}
 		};
 		const sessionScope = yield* Scope.make("sequential");
@@ -74484,6 +74591,7 @@ const CodexDriver = {
 		const adapter = yield* makeCodexAdapter(effectiveConfig, {
 			instanceId,
 			environment: processEnv,
+			resolveMcpServers: (yield* McpRegistry).resolveForSession,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 		});
 		const textGeneration = yield* makeCodexTextGeneration(effectiveConfig, processEnv);
@@ -80076,6 +80184,31 @@ const makeCursorTextGeneration = Effect.fn("makeCursorTextGeneration")(function*
 	};
 });
 //#endregion
+//#region src/provider/acp/acpMcpServers.ts
+const namedPairs = (values) => Object.entries(values).map(([name, value]) => ({
+	name,
+	value
+}));
+/**
+* @param resolved - Servers keyed by name, as the registry resolved them.
+* @param exclude - Names p4code declares itself, which win over a registration
+*   of the same name. The built-in `p4-code` server carries a per-thread
+*   credential no registration can reproduce, so a same-named registration must
+*   not be able to displace it — it would take `task_current` with it, and the
+*   failure would look like the agent forgetting which task it is on.
+*/
+const toAcpMcpServers = (resolved, exclude = /* @__PURE__ */ new Set()) => Object.entries(resolved).filter(([name]) => !exclude.has(name)).map(([name, server]) => server.type === "stdio" ? {
+	name,
+	command: server.command,
+	args: [...server.args],
+	env: namedPairs(server.env)
+} : {
+	type: server.type,
+	name,
+	url: server.url,
+	headers: namedPairs(server.headers)
+});
+//#endregion
 //#region src/provider/acp/AcpAdapterSupport.ts
 const isAcpProcessExitedError = Schema$1.is(AcpProcessExitedError);
 const isAcpRequestError = Schema$1.is(AcpRequestError);
@@ -80560,6 +80693,15 @@ function makeCursorAdapter(cursorSettings, options) {
 			});
 			const effectiveCursorSettings = options?.resolveSettings ? yield* options.resolveSettings : cursorSettings;
 			const mcpSession = readMcpProviderSession(input.threadId);
+			const mcpServers = [...toAcpMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, P4CODE_MCP_SERVER_NAMES), ...mcpSession ? [{
+				type: "http",
+				name: P4CODE_MCP_SERVER_NAME,
+				url: mcpSession.endpoint,
+				headers: [{
+					name: "Authorization",
+					value: mcpSession.authorizationHeader
+				}]
+			}] : []];
 			const acp = yield* makeCursorAcpRuntime({
 				cursorSettings: effectiveCursorSettings,
 				...options?.environment ? { environment: options.environment } : {},
@@ -80567,18 +80709,10 @@ function makeCursorAdapter(cursorSettings, options) {
 				cwd,
 				...resumeSessionId ? { resumeSessionId } : {},
 				clientInfo: {
-					name: "p4-code",
+					name: P4CODE_MCP_SERVER_NAME,
 					version: "0.0.0"
 				},
-				...mcpSession ? { mcpServers: [{
-					type: "http",
-					name: "p4-code",
-					url: mcpSession.endpoint,
-					headers: [{
-						name: "Authorization",
-						value: mcpSession.authorizationHeader
-					}]
-				}] } : {},
+				...mcpServers.length > 0 ? { mcpServers } : {},
 				...acpNativeLoggers
 			}).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(Scope.Scope, sessionScope), Effect.mapError((cause) => new ProviderAdapterProcessError({
 				provider: PROVIDER$3,
@@ -81059,6 +81193,7 @@ const CursorDriver = {
 		});
 		const adapter = yield* makeCursorAdapter(effectiveConfig, {
 			environment: processEnv,
+			resolveMcpServers: (yield* McpRegistry).resolveForSession,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {},
 			instanceId
 		});
@@ -81781,6 +81916,15 @@ function makeGrokAdapter(grokSettings, options) {
 				threadId: input.threadId
 			});
 			const mcpSession = readMcpProviderSession(input.threadId);
+			const mcpServers = [...toAcpMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, P4CODE_MCP_SERVER_NAMES), ...mcpSession ? [{
+				type: "http",
+				name: P4CODE_MCP_SERVER_NAME,
+				url: mcpSession.endpoint,
+				headers: [{
+					name: "Authorization",
+					value: mcpSession.authorizationHeader
+				}]
+			}] : []];
 			const acp = yield* makeGrokAcpRuntime({
 				grokSettings,
 				...options?.environment ? { environment: options.environment } : {},
@@ -81788,18 +81932,10 @@ function makeGrokAdapter(grokSettings, options) {
 				cwd,
 				...resumeSessionId ? { resumeSessionId } : {},
 				clientInfo: {
-					name: "p4-code",
+					name: P4CODE_MCP_SERVER_NAME,
 					version: "0.0.0"
 				},
-				...mcpSession ? { mcpServers: [{
-					type: "http",
-					name: "p4-code",
-					url: mcpSession.endpoint,
-					headers: [{
-						name: "Authorization",
-						value: mcpSession.authorizationHeader
-					}]
-				}] } : {},
+				...mcpServers.length > 0 ? { mcpServers } : {},
 				...acpNativeLoggers
 			}).pipe(Effect.provideService(Crypto.Crypto, crypto), Effect.provideService(Scope.Scope, sessionScope), Effect.mapError((cause) => new ProviderAdapterProcessError({
 				provider: PROVIDER$2,
@@ -82615,6 +82751,7 @@ const GrokDriver = {
 		});
 		const adapter = yield* makeGrokAdapter(effectiveConfig, {
 			environment: processEnv,
+			resolveMcpServers: (yield* McpRegistry).resolveForSession,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {},
 			instanceId
 		});
@@ -84452,6 +84589,27 @@ const makeOpenCodeTextGeneration = Effect.fn("makeOpenCodeTextGeneration")(funct
 	};
 });
 //#endregion
+//#region src/provider/Layers/openCodeMcpServers.ts
+/**
+* @param resolved - Servers keyed by name, as the registry resolved them.
+* @param exclude - Names p4code declares itself, which a registration must not
+*   be able to displace: the built-in `p4-code` server carries the per-thread
+*   credential behind `task_current` and the thread tools.
+*/
+const toOpenCodeMcpServers = (resolved, exclude = /* @__PURE__ */ new Set()) => Object.entries(resolved).filter(([name]) => !exclude.has(name)).map(([name, server]) => ({
+	name,
+	config: server.type === "stdio" ? {
+		type: "local",
+		command: [server.command, ...server.args],
+		...Object.keys(server.env).length > 0 ? { environment: server.env } : {}
+	} : {
+		type: "remote",
+		url: server.url,
+		...Object.keys(server.headers).length > 0 ? { headers: server.headers } : {},
+		oauth: false
+	}
+}));
+//#endregion
 //#region src/provider/Layers/OpenCodeAdapter.ts
 const PROVIDER = ProviderDriverKind.make("opencode");
 /**
@@ -85128,8 +85286,15 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 						...server.external && serverPassword ? { serverPassword } : {}
 					});
 					const mcpSession = readMcpProviderSession(input.threadId);
+					if (!server.external) {
+						const externalMcpServers = toOpenCodeMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, P4CODE_MCP_SERVER_NAMES);
+						for (const entry of externalMcpServers) yield* runOpenCodeSdk("mcp.add", () => client.mcp.add(entry)).pipe(Effect.catchCause((cause) => Effect.logWarning("opencode rejected an mcp registration", {
+							server: entry.name,
+							cause
+						})));
+					}
 					if (mcpSession && !server.external) yield* runOpenCodeSdk("mcp.add", () => client.mcp.add({
-						name: "p4-code",
+						name: P4CODE_MCP_SERVER_NAME,
 						config: {
 							type: "remote",
 							url: mcpSession.endpoint,
@@ -85818,6 +85983,7 @@ const BUILT_IN_DRIVERS = [
 			const adapter = yield* makeOpenCodeAdapter(effectiveConfig, {
 				instanceId,
 				environment: processEnv,
+				resolveMcpServers: (yield* McpRegistry).resolveForSession,
 				...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 			});
 			const textGeneration = yield* makeOpenCodeTextGeneration(effectiveConfig, processEnv);
@@ -86490,7 +86656,29 @@ const TaskProposeTool = Tool.make("task_propose", {
 	failure: TaskToolError,
 	dependencies
 }).annotate(Tool.Title, "Propose a task").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
-const TaskToolkit = Toolkit.make(TaskListTool, TaskGetTool, TaskCurrentTool, TaskCreateTool, TaskUpdateTool, TaskProposeTool);
+/**
+* Reading a tracker ticket, for every provider rather than only the ones that
+* can talk to the tracker themselves.
+*
+* p4code resolves this server-side through the Linear server the user
+* registered once in Settings, so an agent gets the ticket whether or not its
+* own runtime was handed that registration. Without it, a thread started from
+* "MOBILE-12241" on a provider with no tracker of its own can only ask the user
+* to paste the description back in - which is the question they already
+* answered by quoting the id.
+*
+* On the task toolkit rather than a toolkit of its own because it is board
+* work: a resolved ticket's next step is `task_create` with the `externalRef`
+* this returns, and the two share the one capability a session is granted.
+*/
+const TicketResolveTool = Tool.make("ticket_resolve", {
+	description: "Read a tracker ticket by id or URL (e.g. MOBILE-12241, or a linear.app link), returning its identifier, canonical URL, title and description. Use this whenever the user names a ticket rather than asking them to paste it. Pass the returned externalRef straight to task_create to mirror the ticket onto the board. Fails when no tracker is registered on this machine, which is a thing only the user can fix.",
+	parameters: TicketResolveInput,
+	success: TicketResolveResult,
+	failure: Schema$1.Union([TaskToolUnavailableError, TicketResolveError]),
+	dependencies: [McpInvocationContext, TicketResolver]
+}).annotate(Tool.Title, "Resolve a ticket").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const TaskToolkit = Toolkit.make(TaskListTool, TaskGetTool, TaskCurrentTool, TaskCreateTool, TaskUpdateTool, TaskProposeTool, TicketResolveTool);
 //#endregion
 //#region src/mcp/toolkits/tasks/handlers.ts
 const nowIso$1 = Effect.map(DateTime.now, DateTime.formatIso);
@@ -86576,6 +86764,10 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 		if (Option.isNone(patched)) return yield* new TaskNotFoundError({ taskId: input.taskId });
 		return patched.value;
 	}),
+	ticket_resolve: (input) => Effect.gen(function* () {
+		yield* requireTaskCapability();
+		return yield* (yield* TicketResolver).resolve(input.reference);
+	}),
 	task_propose: () => Effect.gen(function* () {
 		yield* requireTaskCapability();
 		return { awaitingConfirmation: true };