@alpic-ai/tracks 0.0.0-stage → 0.4.0

package/dist/main.js

@@ -0,0 +1,1074 @@
+#!/usr/bin/env node
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity, OpenApi } from "effect/http-api";
+import { Config, Console, Context, Deferred, Effect, Layer, Option, Redacted, Result, Schema, SchemaTransformation, Stream, Struct } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { isIPv4 } from "node:net";
+import { Argument, Command, Flag } from "effect/cli";
+import { createServer } from "node:http";
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
+//#region ../contract/src/authorization.ts
+const ORGANIZATION_HEADER = "x-organization";
+Context.Service()("@tracks/contract/CurrentOrganization");
+var Unauthorized = class extends Schema.TaggedError()("Unauthorized", { message: Schema.String }, {
+	httpApiStatus: 401,
+	description: `The Agent Runner key is missing or invalid, or no \`${ORGANIZATION_HEADER}\` header names the Organization.`
+}) {};
+var Authorization = class extends HttpApiMiddleware.Service()("@tracks/contract/Authorization", {
+	requiredForClient: true,
+	security: { bearer: HttpApiSecurity.http({ scheme: "bearer" }).pipe(HttpApiSecurity.annotate(OpenApi.Description, `The Agent Runner key, sent as \`Authorization: Bearer <key>\`, with the Organization the request is made for in the \`${ORGANIZATION_HEADER}\` header.`)) },
+	error: Unauthorized
+}) {};
+const OptionalQueryParam = (schema, description) => Schema.optionalKey(schema).annotateKey({ description }).pipe(Schema.decodeTo(Schema.Option(Schema.toType(schema)), SchemaTransformation.optionFromOptionalKey()));
+const ListQuery = {
+	after: OptionalQueryParam(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), "Return only items after this position."),
+	limit: OptionalQueryParam(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 1e3
+	})), `Maximum number of items to return, from 1 to 1000. Defaults to 100.`)
+};
+const List = (item) => Schema.Struct({
+	data: Schema.Array(item),
+	has_more: Schema.Boolean.annotate({ description: "Whether more items are available after this page." })
+});
+//#endregion
+//#region ../contract/src/validation.ts
+const RequestIssue = Schema.Struct({
+	path: Schema.Array(Schema.Union([Schema.String, Schema.Number])).annotate({ description: "Keys leading to the wrong value inside that part of the request, such as `[\"agent\", \"model\"]`. Empty when the problem concerns that part as a whole." }),
+	message: Schema.String.annotate({ description: "What is wrong with the value." })
+}).annotate({
+	identifier: "RequestIssue",
+	description: "One problem found in the request."
+});
+var InvalidRequest = class extends Schema.TaggedError()("InvalidRequest", {
+	message: Schema.String.annotate({ description: "Every problem found, in one sentence." }),
+	location: Schema.Literals([
+		"path",
+		"query",
+		"header",
+		"body"
+	]).annotate({ description: "The part of the request that is wrong." }),
+	issues: Schema.Array(RequestIssue).annotate({ description: "Each problem found, with where it is." })
+}, {
+	httpApiStatus: 400,
+	description: "The request is invalid: a value is missing, has the wrong type or is out of range. Fix it before sending the request again."
+}) {};
+var RequestValidation = class extends HttpApiMiddleware.Service()("@tracks/contract/RequestValidation", { error: InvalidRequest }) {};
+//#endregion
+//#region ../contract/src/connections.ts
+const ConnectionId = Schema.String.pipe(Schema.brand("ConnectionId")).annotate({
+	identifier: "ConnectionId",
+	description: "Unique identifier of the connection."
+});
+const HttpsUrl = Schema.String.check(Schema.makeFilter((url) => URL.parse(url)?.protocol === "https:" || "must be an https URL"));
+const CreateConnectionInput = Schema.Struct({
+	server_url: HttpsUrl.annotate({ description: "URL of the MCP server to connect to." }),
+	return_url: Schema.OptionFromOptionalKey(Schema.String.check(Schema.makeFilter((url) => URL.canParse(url) || "must be a URL")).annotate({ description: "Optional. Omit it when you cannot receive the user's browser, as an agent or a script: the user then sees a code such as `K7QM-4XPD` to give back to you. Otherwise, where the browser is sent back once they consented or refused, on an allowed origin or on `http://127.0.0.1`, `http://[::1]` or `http://localhost` at any port for a program running on the user's machine. It gets `connection_id`, then `confirmation` on success or `error` otherwise." }))
+}).annotate({ identifier: "CreateConnectionInput" });
+const ConfirmConnectionInput = Schema.Struct({ confirmation: Schema.NonEmptyString.annotate({ description: "The `confirmation` your return URL received, or the code the user gave you, proving the consent came back to you. Valid for 10 minutes after the consent." }) }).annotate({ identifier: "ConfirmConnectionInput" });
+const connectionFields = {
+	id: ConnectionId,
+	server_url: Schema.String.annotate({ description: "URL of the MCP server." }),
+	created_at: Schema.DateTimeUtc.annotate({ description: "When the connection was created." })
+};
+const Connection = Schema.Union([Schema.Struct({
+	...connectionFields,
+	status: Schema.Literals([
+		"authorizing",
+		"unconfirmed",
+		"active"
+	]).annotate({ description: "`authorizing` until the user consents on the MCP server, `unconfirmed` until you confirm it, `active` once it can be used." })
+}).annotate({
+	identifier: "WorkingConnection",
+	description: "A connection that has not failed."
+}), Schema.Struct({
+	...connectionFields,
+	status: Schema.Literal("failed"),
+	failure: Schema.String.annotate({ description: "Why the consent did not complete." })
+}).annotate({
+	identifier: "FailedConnection",
+	description: "A connection whose consent did not complete."
+})]).annotate({ description: "Access to an MCP server as one of its users, kept by Agent Runner." });
+const CreatedConnection = Schema.Struct({
+	connection: Connection,
+	consent_url: Schema.String.annotate({ description: "Send the user's browser there to consent on the MCP server. Valid for 10 minutes, once. The browser then comes back to your `return_url`, or shows the confirmation code without one." })
+}).annotate({ identifier: "CreatedConnection" });
+var ConnectionNotFound = class extends Schema.TaggedError()("ConnectionNotFound", { message: Schema.String }, {
+	httpApiStatus: 404,
+	description: "No connection with this id exists for this Organization."
+}) {};
+var ConnectionRefused = class extends Schema.TaggedError()("ConnectionRefused", { message: Schema.String }, {
+	httpApiStatus: 422,
+	description: "The connection cannot be started: the return URL is not allowed, or the MCP server cannot be authorized in a way Agent Runner supports."
+}) {};
+var ServerUnreachable = class extends Schema.TaggedError()("ServerUnreachable", { message: Schema.String }, {
+	httpApiStatus: 502,
+	description: "The MCP server or its authorization server could not be reached."
+}) {};
+var ConfirmationRefused = class extends Schema.TaggedError()("ConfirmationRefused", { message: Schema.String }, {
+	httpApiStatus: 409,
+	description: "The connection is not waiting for this confirmation."
+}) {};
+var ConnectionsApi = class extends HttpApiGroup.make("connections").add(HttpApiEndpoint.post("create", "/connections", {
+	payload: CreateConnectionInput,
+	success: CreatedConnection.pipe(HttpApiSchema.status(201)),
+	error: [ConnectionRefused, ServerUnreachable]
+}).annotateMerge(OpenApi.annotations({
+	summary: "Create a connection",
+	description: "Starts connecting to an MCP server that acts as one of its users. Send the user's browser to `consent_url`. Once they consent, they get a `confirmation`: as a code shown to them, to give back to you, or, if you passed the optional `return_url`, sent to it with `connection_id`. Confirm the connection with it within 10 minutes to make it `active`, then give its MCP server's URL to runs."
+})), HttpApiEndpoint.get("list", "/connections", { success: List(Connection) }).annotateMerge(OpenApi.annotations({
+	summary: "List connections",
+	description: "Returns every connection."
+})), HttpApiEndpoint.get("get", "/connections/:id", {
+	params: { id: ConnectionId },
+	success: Connection,
+	error: ConnectionNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Get a connection",
+	description: "Returns a connection."
+})), HttpApiEndpoint.post("confirm", "/connections/:id/confirm", {
+	params: { id: ConnectionId },
+	payload: ConfirmConnectionInput,
+	success: Connection,
+	error: [ConnectionNotFound, ConfirmationRefused]
+}).annotateMerge(OpenApi.annotations({
+	summary: "Confirm a connection",
+	description: "Makes an `unconfirmed` connection `active`. Confirm it only when the browser that came back to your return URL belongs to the user who started the connection."
+})), HttpApiEndpoint.delete("delete", "/connections/:id", {
+	params: { id: ConnectionId },
+	success: HttpApiSchema.NoContent,
+	error: ConnectionNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Delete a connection",
+	description: "Deletes a connection and the access it holds."
+}))).middleware(Authorization).middleware(RequestValidation).annotateMerge(OpenApi.annotations({
+	title: "Connections",
+	description: "Let agents use MCP servers as one of their users, without their credentials entering the sandbox."
+})) {};
+//#endregion
+//#region ../contract/src/runs.ts
+const RunId = Schema.String.pipe(Schema.brand("RunId")).annotate({
+	identifier: "RunId",
+	description: "Unique identifier of the run."
+});
+const Harness = Schema.Literals([
+	"claude-code",
+	"codex",
+	"codex-app"
+]).annotate({
+	identifier: "Harness",
+	description: "The coding agent to run: `claude-code` (Claude Code), `codex` (OpenAI's Codex CLI) or `codex-app` (the Codex mode of OpenAI's ChatGPT desktop app, with its browser, computer-use and document tools)."
+});
+const Agent = Schema.Struct({
+	harness: Harness,
+	model: Schema.NonEmptyString.annotate({ description: "Model the agent uses, such as `claude-sonnet-5-5`." })
+}).annotate({
+	identifier: "Agent",
+	description: "The coding agent and the model it uses."
+});
+const repository = Schema.OptionFromOptionalKey(Schema.NonEmptyString.annotate({ description: "URL of a Git repository to clone before the agent starts." }));
+const MAX_SCRIPT_LENGTH = 32768;
+const script = (description) => Schema.OptionFromOptionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(MAX_SCRIPT_LENGTH)).annotate({ description: `${description} At most ${MAX_SCRIPT_LENGTH} characters.` }));
+const setup = script("Shell script run with bash in the repository directory after checkout and before the first prompt, with the run's variables set, while the run is `preparing`. A non-zero exit fails the run. It may run again if Agent Runner restarts mid-way: make it idempotent.");
+const teardown = script("Shell script run with bash in the repository directory after the run ends and before its sandbox is destroyed, with the run's variables set. Its exit code doesn't change how the run ended. It may run again if Agent Runner restarts mid-way: make it idempotent.");
+const VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const RESERVED_VARIABLES = /* @__PURE__ */ new Set(["PATH", "HOME"]);
+const RESERVED_VARIABLE_PREFIXES = [
+	"ANTHROPIC_",
+	"CLAUDE_",
+	"OPENAI_",
+	"CODEX_",
+	"AGENT_RUNNER_"
+];
+const isReservedVariable = (name) => RESERVED_VARIABLES.has(name) || RESERVED_VARIABLE_PREFIXES.some((prefix) => name.startsWith(prefix));
+const MAX_VARIABLES = 100;
+const MAX_VARIABLE_VALUE_LENGTH = 32768;
+const Variables$1 = Schema.Record(Schema.String, Schema.String.check(Schema.isMaxLength(MAX_VARIABLE_VALUE_LENGTH))).annotate({ description: `Environment variables set in every process of the agent, by name. Their values are never returned. Names match \`^[A-Za-z_][A-Za-z0-9_]*$\`; at most ${MAX_VARIABLES} variables of up to ${MAX_VARIABLE_VALUE_LENGTH} characters each. \`PATH\`, \`HOME\` and names starting with \`ANTHROPIC_\`, \`CLAUDE_\`, \`OPENAI_\`, \`CODEX_\` or \`AGENT_RUNNER_\` are reserved for running the agent.` }).check(Schema.isMaxProperties(MAX_VARIABLES), Schema.makeFilter((variables) => Object.keys(variables).flatMap((name) => {
+	if (!VARIABLE_NAME.test(name)) return [{
+		path: [name],
+		issue: `Expected a name matching ${VARIABLE_NAME.source}`
+	}];
+	if (isReservedVariable(name)) return [{
+		path: [name],
+		issue: "Expected a name not reserved for the agent"
+	}];
+	return [];
+})));
+const MCP_SERVER_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+const MAX_MCP_SERVERS = 20;
+const RESERVED_MCP_SERVER_NAMES = /* @__PURE__ */ new Set(["chatgpt_plugins"]);
+const McpServerName = Schema.String.check(Schema.isPattern(MCP_SERVER_NAME)).annotate({ description: "Name the agent knows the MCP server by, unique in the run, matching `^[A-Za-z0-9_-]{1,64}$`, such as `linear`. `chatgpt_plugins` is reserved for running the agent." });
+const McpServerInput = Schema.Union([Schema.Struct({
+	name: McpServerName,
+	url: HttpsUrl.annotate({ description: "URL of the MCP server. When you have one `active` connection to this exact URL, the agent uses it; otherwise the server is used without one. Requests come from the addresses listed at `GET /egress-ips`." }),
+	connection_id: Schema.optionalKey(Schema.Never)
+}).annotate({
+	identifier: "McpServerByUrlInput",
+	description: "An MCP server given by its URL."
+}), Schema.Struct({
+	name: McpServerName,
+	connection_id: ConnectionId.annotate({ description: "An `active` connection: the agent uses its MCP server as the user who consented." }),
+	url: Schema.optionalKey(Schema.Never)
+}).annotate({
+	identifier: "McpServerByConnectionInput",
+	description: "An MCP server given by a connection to it, to pick between several accounts."
+})]).annotate({
+	identifier: "McpServerInput",
+	description: "An MCP server the agent can use, through Agent Runner: credentials never enter the sandbox. Set `url` or `connection_id`."
+});
+const McpServersInput = Schema.Array(McpServerInput).check(Schema.isMaxLength(MAX_MCP_SERVERS), Schema.makeFilter((servers) => {
+	const names = servers.map((server) => server.name);
+	return new Set(names).size === names.length || "MCP server names must be unique";
+}), Schema.makeFilter((servers) => servers.flatMap((server, index) => RESERVED_MCP_SERVER_NAMES.has(server.name) ? [{
+	path: [index, "name"],
+	issue: "Expected a name not reserved for the agent"
+}] : []))).annotate({ description: `MCP servers the agent can use, at most ${MAX_MCP_SERVERS}.` });
+const EnvironmentInput = Schema.Struct({
+	repository,
+	variables: Schema.OptionFromOptionalKey(Variables$1),
+	setup,
+	teardown,
+	mcp_servers: Schema.OptionFromOptionalKey(McpServersInput)
+}).annotate({
+	identifier: "EnvironmentInput",
+	description: "What the agent works on."
+});
+const RunMcpServer = Schema.Struct({
+	name: Schema.String.annotate({ description: "Name the agent knows the MCP server by." }),
+	url: Schema.String.annotate({ description: "URL of the MCP server." }),
+	connection_id: Schema.OptionFromOptionalKey(ConnectionId.annotate({ description: "The connection the agent uses it through, if any." }))
+}).annotate({
+	identifier: "McpServer",
+	description: "An MCP server the agent can use."
+});
+const RunEnvironment = Schema.Struct({
+	repository,
+	variables: Schema.Array(Schema.String).annotate({ description: "Names of the environment variables set in every process of the agent. Their values are never returned." }),
+	setup,
+	teardown,
+	mcp_servers: Schema.Array(RunMcpServer)
+}).annotate({
+	identifier: "Environment",
+	description: "What the agent works on."
+});
+const Budget = Schema.Finite.check(Schema.isBetween({
+	minimum: .01,
+	maximum: 1e4
+})).annotate({ description: "Maximum the run may spend, in US dollars. Defaults to a standard budget when omitted. The run ends with `budget_exceeded` once it is reached." });
+const MIN_IDLE_TIMEOUT_SECONDS = 120;
+const MAX_IDLE_TIMEOUT_SECONDS = 900;
+const MIN_TIME_LIMIT_SECONDS = 60;
+const MAX_TIME_LIMIT_SECONDS = 43200;
+const CreateRunInput = Schema.Struct({
+	agent: Agent,
+	prompt: Schema.NonEmptyString.annotate({ description: "What you ask the agent to do first." }),
+	environment: EnvironmentInput,
+	budget_usd: Schema.OptionFromOptionalKey(Budget),
+	one_shot: Schema.OptionFromOptionalKey(Schema.Boolean.annotate({ description: "Whether the run ends as soon as its first prompt finishes. Defaults to `true`. Set it to `false` to send follow-up prompts while the run is `idle`." })),
+	idle_timeout_seconds: Schema.OptionFromOptionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: MIN_IDLE_TIMEOUT_SECONDS,
+		maximum: MAX_IDLE_TIMEOUT_SECONDS
+	})).annotate({ description: `How long the run waits for a follow-up prompt before it ends with \`idle_timeout\`, in seconds, from ${MIN_IDLE_TIMEOUT_SECONDS} to ${MAX_IDLE_TIMEOUT_SECONDS}. Defaults to ${MAX_IDLE_TIMEOUT_SECONDS}. Only allowed when \`one_shot\` is \`false\`.` })),
+	time_limit_seconds: Schema.OptionFromOptionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: MIN_TIME_LIMIT_SECONDS,
+		maximum: MAX_TIME_LIMIT_SECONDS
+	})).annotate({ description: `Longest the run may last, in seconds from when it starts, from ${MIN_TIME_LIMIT_SECONDS} to ${MAX_TIME_LIMIT_SECONDS}. Defaults to 7200. Once reached, the run ends with \`time_limit\`, even in the middle of a prompt.` }))
+}).check(Schema.makeFilter((input) => Option.contains(input.one_shot, false) || Option.isNone(input.idle_timeout_seconds) || "idle_timeout_seconds is only allowed when one_shot is false")).annotate({ identifier: "CreateRunInput" });
+const SubmitPromptInput = Schema.Struct({
+	text: Schema.NonEmptyString.annotate({ description: "What you ask the agent to do next." }),
+	model: Schema.OptionFromOptionalKey(Schema.NonEmptyString.annotate({ description: "Model for this prompt only. Defaults to the run's model." }))
+}).annotate({ identifier: "SubmitPromptInput" });
+const PromptIndex = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)).annotate({ description: "Position of the prompt in its run, starting at 1." });
+const promptFields = {
+	run_id: RunId,
+	index: PromptIndex,
+	text: Schema.String.annotate({ description: "What you asked the agent to do." }),
+	model: Schema.OptionFromOptionalKey(Schema.String.annotate({ description: "Model for this prompt, when not the run's." })),
+	submitted_at: Schema.DateTimeUtc.annotate({ description: "When the prompt was submitted." })
+};
+const Prompt = Schema.Union([Schema.Struct({
+	...promptFields,
+	status: Schema.Literals([
+		"working",
+		"failed",
+		"canceled"
+	]).annotate({ description: "`working` while the agent works on it. `failed` or `canceled` when the run ended before the prompt finished." })
+}).annotate({
+	identifier: "UnfinishedPrompt",
+	description: "A prompt the agent has not finished."
+}), Schema.Struct({
+	...promptFields,
+	status: Schema.Literal("finished").annotate({ description: "The agent stopped, whatever its exit code." }),
+	finished_at: Schema.DateTimeUtc.annotate({ description: "When the agent stopped." }),
+	exit_code: Schema.Int.annotate({ description: "Exit code of the agent." })
+}).annotate({
+	identifier: "FinishedPrompt",
+	description: "A prompt the agent has finished."
+})]).annotate({ description: "One instruction to the agent and the work it did in response." });
+const EndReason = Schema.Literals([
+	"completed",
+	"idle_timeout",
+	"time_limit",
+	"budget_exceeded",
+	"failed",
+	"canceled"
+]).annotate({
+	identifier: "EndReason",
+	description: "Why the run ended. When `failed`, `failure` explains what went wrong."
+});
+const FailureKind = Schema.Literals([
+	"repository_checkout_failed",
+	"setup_failed",
+	"sandbox_not_found",
+	"process_lost",
+	"sandbox_unavailable",
+	"unexpected"
+]).annotate({
+	identifier: "FailureKind",
+	description: "What kind of thing went wrong: the repository could not be checked out, the environment's setup command failed, the sandbox disappeared, the agent's process was lost, the sandbox provider failed, or something unexpected."
+});
+const runFields = {
+	id: RunId,
+	agent: Agent,
+	environment: RunEnvironment,
+	budget_usd: Schema.Number.annotate({ description: "Maximum the run may spend, in US dollars." }),
+	one_shot: Schema.Boolean.annotate({ description: "Whether the run ends as soon as its first prompt finishes." }),
+	idle_timeout_seconds: Schema.OptionFromOptionalKey(Schema.Int.annotate({ description: "How long the run waits for a follow-up prompt before it ends, in seconds. Absent for a one-shot run." })),
+	time_limit_seconds: Schema.Int.annotate({ description: "Longest the run may last, in seconds from when it starts." }),
+	started_at: Schema.DateTimeUtc.annotate({ description: "When the run started." }),
+	last_prompt: Prompt
+};
+const endedRunFields = {
+	...runFields,
+	status: Schema.Literal("ended"),
+	ended_at: Schema.DateTimeUtc.annotate({ description: "When the run ended." })
+};
+const Run = Schema.Union([
+	Schema.Struct({
+		...runFields,
+		status: Schema.Literals([
+			"preparing",
+			"working",
+			"idle"
+		]).annotate({ description: "`preparing` while its sandbox gets ready, `working` while the agent works on a prompt, `idle` while it waits for a follow-up prompt." })
+	}).annotate({
+		identifier: "ActiveRun",
+		description: "A run that has not ended."
+	}),
+	Schema.Struct({
+		...endedRunFields,
+		end_reason: EndReason.pick([
+			"completed",
+			"idle_timeout",
+			"time_limit",
+			"budget_exceeded",
+			"canceled"
+		])
+	}).annotate({
+		identifier: "EndedRun",
+		description: "A run that ended without failing."
+	}),
+	Schema.Struct({
+		...endedRunFields,
+		end_reason: Schema.Literal("failed"),
+		failure: Schema.String.annotate({ description: "What went wrong." }),
+		failure_kind: FailureKind
+	}).annotate({
+		identifier: "FailedRun",
+		description: "A run that ended because something went wrong."
+	})
+]).annotate({ description: "A coding agent working on your prompt in an isolated sandbox." });
+var RunNotFound = class extends Schema.TaggedError()("RunNotFound", { message: Schema.String }, {
+	httpApiStatus: 404,
+	description: "No run with this id exists for this Organization."
+}) {};
+var ConnectionUnusable = class extends Schema.TaggedError()("ConnectionUnusable", { message: Schema.String }, {
+	httpApiStatus: 422,
+	description: "A `connection_id` in `environment.mcp_servers` does not exist or is not `active`, or a `url` matches several `active` connections: pick one with `connection_id`."
+}) {};
+var ModelNotOffered = class extends Schema.TaggedError()("ModelNotOffered", { message: Schema.String }, {
+	httpApiStatus: 422,
+	description: "The agent cannot use this model. The message lists the models it can use."
+}) {};
+var RunNotIdle = class extends Schema.TaggedError()("RunNotIdle", { message: Schema.String }, {
+	httpApiStatus: 409,
+	description: "The run accepts no prompt now: it is one-shot, has ended, or is still working on a prompt."
+}) {};
+const Count = Schema.Natural;
+const RunUsage = Schema.Struct({
+	cost_usd: Schema.Number.annotate({ description: "Total cost of the run so far, in US dollars." }),
+	models: Schema.Array(Schema.Struct({
+		provider: Schema.String.annotate({ description: "Company serving the model, such as `anthropic`." }),
+		model: Schema.String,
+		quantities: Schema.Record(Schema.String, Count).annotate({ description: "Units consumed, keyed by unit as the provider counts them, such as input tokens or web searches." }),
+		cost_usd: Schema.Number.annotate({ description: "Cost of this model's usage, in US dollars." })
+	})).annotate({ description: "Model usage, one entry per model." }),
+	sandbox: Schema.Struct({
+		seconds: Schema.Number.annotate({ description: "Time the sandbox ran, in seconds." }),
+		cost_usd: Schema.Number.annotate({ description: "Cost of the sandbox time, in US dollars." })
+	})
+}).annotate({
+	identifier: "RunUsage",
+	description: "What a run consumed and what it cost."
+});
+const Frame = Schema.Struct({
+	run_id: RunId,
+	seq: Schema.Int.annotate({ description: "Position of the line in the run's output, starting at 1. Always increasing, but some numbers may be skipped." }),
+	prompt: PromptIndex.annotate({ description: "Index of the prompt the agent was working on." }),
+	captured_at: Schema.DateTimeUtc.annotate({ description: "When the line was captured." }),
+	channel: Schema.Literals(["stdout", "stderr"]).annotate({ description: "Output stream the line came from." }),
+	body: Schema.String.annotate({ description: "The line, exactly as the agent printed it." })
+}).annotate({
+	identifier: "Frame",
+	description: "One line of the agent's output."
+});
+const Outcome = Schema.Literals(["succeeded", "failed"]).annotate({
+	identifier: "Outcome",
+	description: "Whether the tool call or subagent succeeded."
+});
+const ToolCallId = Schema.String.annotate({ description: "Identifier of the tool call, unique in its run." });
+const eventFields = {
+	run_id: RunId,
+	seq: Schema.Int.annotate({ description: "Position of the event in the run, starting at 1. Always increasing, but some numbers may be skipped." }),
+	prompt: PromptIndex.annotate({ description: "Index of the prompt the event belongs to." }),
+	captured_at: Schema.DateTimeUtc.annotate({ description: "When the output the event comes from was captured." }),
+	subagent_id: Schema.OptionFromOptionalKey(ToolCallId.annotate({ description: "The subagent that did it: the `tool_call_id` of the `tool_started` event that launched it. Absent when the run's agent did it." })),
+	frame_seqs: Schema.Array(Schema.Int).annotate({ description: "The `seq` of each output line the event was read from. Empty for events Agent Runner records itself." })
+};
+const Event = Schema.Union([
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("prompt"),
+		text: Schema.String.annotate({ description: "What you asked the agent to do." })
+	}).annotate({
+		identifier: "PromptEvent",
+		description: "A prompt given to the agent; the first event of its prompt."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("message"),
+		text: Schema.String.annotate({ description: "What the agent wrote." })
+	}).annotate({
+		identifier: "MessageEvent",
+		description: "Text the agent wrote, apart from reasoning and tool calls."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("reasoning"),
+		text: Schema.OptionFromOptionalKey(Schema.String.annotate({ description: "The reasoning, or a summary of it. Absent when the harness hides it." }))
+	}).annotate({
+		identifier: "ReasoningEvent",
+		description: "The agent reasoning before it acts."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("tool_started"),
+		tool_call_id: ToolCallId,
+		tool_name: Schema.String.annotate({ description: "Name of the tool, as the harness calls it." }),
+		input: Schema.Json.annotate({ description: "What the agent passed to the tool." })
+	}).annotate({
+		identifier: "ToolStartedEvent",
+		description: "The agent called a tool."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("tool_ended"),
+		tool_call_id: ToolCallId,
+		outcome: Outcome,
+		output: Schema.String.annotate({ description: "What the tool returned, possibly truncated." }),
+		structured: Schema.OptionFromOptionalKey(Schema.Json.annotate({ description: "The structured content an MCP tool returned beside its text, unchanged. Absent when the tool returned none or it was too large." }))
+	}).annotate({
+		identifier: "ToolEndedEvent",
+		description: "A tool call ended; its `tool_call_id` is the one of the `tool_started` event."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("subagent_started"),
+		description: Schema.OptionFromOptionalKey(Schema.String.annotate({ description: "What the agent asked the subagent to do, in short." }))
+	}).annotate({
+		identifier: "SubagentStartedEvent",
+		description: "A subagent started; its `subagent_id` is the `tool_call_id` of the `tool_started` event that launched it. That tool call may end before the subagent does: the subagent is done at its `subagent_ended`."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("subagent_ended"),
+		outcome: Outcome
+	}).annotate({
+		identifier: "SubagentEndedEvent",
+		description: "A subagent ended."
+	}),
+	Schema.Struct({
+		...eventFields,
+		type: Schema.Literal("stop"),
+		stop_reason: Schema.Literals([
+			"completed",
+			"failed",
+			"canceled"
+		]).annotate({ description: "Why the agent stopped. When `failed`, `error` may explain what went wrong." }),
+		error: Schema.OptionFromOptionalKey(Schema.String.annotate({ description: "What went wrong." }))
+	}).annotate({
+		identifier: "StopEvent",
+		description: "The agent stopped working on the prompt; the last event of its prompt. It ends everything still open in the prompt: any tool call or subagent without its own end event ended with it."
+	})
+]).annotate({ description: "One thing the agent did, read from its output so that runs of every harness read alike." });
+const FrameStreamItem = Schema.Union([Schema.Struct({
+	id: Schema.optional(Schema.String),
+	event: Schema.Literal("frame"),
+	data: Schema.fromJsonString(Schema.toCodecJson(Frame))
+}), Schema.Struct({
+	id: Schema.optional(Schema.String),
+	event: Schema.Literal("heartbeat"),
+	data: Schema.Literal("")
+})]);
+const EventStreamItem = Schema.Union([Schema.Struct({
+	id: Schema.optional(Schema.String),
+	event: Schema.Literal("event"),
+	data: Schema.fromJsonString(Schema.toCodecJson(Event))
+}), Schema.Struct({
+	id: Schema.optional(Schema.String),
+	event: Schema.Literal("heartbeat"),
+	data: Schema.Literal("")
+})]);
+var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("create", "/runs", {
+	headers: { "idempotency-key": Schema.OptionFromOptionalKey(Schema.NonEmptyString.check(Schema.isMaxLength(255)).annotate({ description: "A unique value you choose, up to 255 characters, to retry safely: a request with a key already used in your organization returns the run the first request created, without starting another, whatever its body." })) },
+	payload: CreateRunInput,
+	success: Run.pipe(HttpApiSchema.status(201)),
+	error: [ModelNotOffered, ConnectionUnusable]
+}).annotateMerge(OpenApi.annotations({
+	summary: "Create a run",
+	description: "Starts a coding agent on your prompt in a fresh sandbox. A one-shot run, the default, ends when the agent finishes; otherwise the run waits `idle` for follow-up prompts until you end it or it times out. Send an `Idempotency-Key` header to retry without creating a second run."
+})), HttpApiEndpoint.get("get", "/runs/:id", {
+	params: { id: RunId },
+	success: Run,
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Get a run",
+	description: "Returns a run and its current status."
+})), HttpApiEndpoint.get("getUsage", "/runs/:id/usage", {
+	params: { id: RunId },
+	success: RunUsage,
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Get run usage",
+	description: "Returns what the run has consumed so far, per model and in sandbox time, and what it cost."
+})), HttpApiEndpoint.post("end", "/runs/:id/end", {
+	params: { id: RunId },
+	success: Run.pipe(HttpApiSchema.status(202)),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "End a run",
+	description: "Ends the run with `completed` once its current prompt finishes, then destroys its sandbox. Ending a run that has ended does nothing."
+})), HttpApiEndpoint.post("cancel", "/runs/:id/cancel", {
+	params: { id: RunId },
+	success: Run.pipe(HttpApiSchema.status(202)),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Cancel a run",
+	description: "Stops the agent right away, even mid-prompt, ends the run with `canceled`, then destroys its sandbox. Canceling a run that has ended does nothing."
+})), HttpApiEndpoint.post("submitPrompt", "/runs/:id/prompts", {
+	params: { id: RunId },
+	payload: SubmitPromptInput,
+	success: Prompt.pipe(HttpApiSchema.status(202)),
+	error: [
+		RunNotFound,
+		RunNotIdle,
+		ModelNotOffered
+	]
+}).annotateMerge(OpenApi.annotations({
+	summary: "Send a follow-up prompt",
+	description: "Asks the agent to continue where its last prompt stopped. Accepted only while the run is `idle`; the run is `working` again until the agent stops."
+})), HttpApiEndpoint.get("listPrompts", "/runs/:id/prompts", {
+	params: { id: RunId },
+	query: ListQuery,
+	success: List(Prompt),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "List run prompts",
+	description: "Returns the run's prompts in order. To get the next page, pass the `index` of the last prompt received as `after`."
+})), HttpApiEndpoint.get("listFrames", "/runs/:id/frames", {
+	params: { id: RunId },
+	query: {
+		...ListQuery,
+		prompt: OptionalQueryParam(PromptIndex, "Return only this prompt's output.")
+	},
+	success: List(Frame),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "List run output",
+	description: "Returns the agent's output, line by line, in order. To get the next page, pass the `seq` of the last line received as `after`."
+})), HttpApiEndpoint.get("listEvents", "/runs/:id/events", {
+	params: { id: RunId },
+	query: {
+		...ListQuery,
+		prompt: OptionalQueryParam(PromptIndex, "Return only this prompt's events.")
+	},
+	success: List(Event),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "List run events",
+	description: "Returns what the agent did, in order: each prompt, then its messages, reasoning, tool calls and subagents, then a `stop` once the agent stopped. Events read alike whatever the harness, and are read from the run's output: `frame_seqs` points at the lines each one comes from. To get the next page, pass the `seq` of the last event received as `after`."
+})), HttpApiEndpoint.get("followFrames", "/runs/:id/frames/stream", {
+	params: { id: RunId },
+	query: { after: OptionalQueryParam(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), "Send only lines whose `seq` is greater than this.") },
+	success: HttpApiSchema.StreamSse({ events: FrameStreamItem }),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Stream run output",
+	description: "Sends the agent's output as server-sent events as it is produced: a `frame` event per line, its data the line as JSON, and a `heartbeat` event every 30 seconds to keep the connection open. Closes once the run has ended and every line was sent. The connection may also close earlier; to pick up where it stopped, call again with the `seq` of the last line received as `after`, or let an SSE client reconnect: the `Last-Event-ID` header it sends is used when `after` is absent."
+})), HttpApiEndpoint.get("followEvents", "/runs/:id/events/stream", {
+	params: { id: RunId },
+	query: { after: OptionalQueryParam(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)), "Send only events whose `seq` is greater than this.") },
+	success: HttpApiSchema.StreamSse({ events: EventStreamItem }),
+	error: RunNotFound
+}).annotateMerge(OpenApi.annotations({
+	summary: "Stream run events",
+	description: "Sends what the agent did as server-sent events as it happens: an `event` event per event, its data the event as JSON, and a `heartbeat` event every 30 seconds to keep the connection open. Closes once the run has ended and every event was sent. The connection may also close earlier; to pick up where it stopped, call again with the `seq` of the last event received as `after`, or let an SSE client reconnect: the `Last-Event-ID` header it sends is used when `after` is absent."
+}))).middleware(Authorization).middleware(RequestValidation).annotateMerge(OpenApi.annotations({
+	title: "Runs",
+	description: "Start coding agents and follow their work."
+})) {};
+//#endregion
+//#region ../contract/src/system.ts
+const EgressIps = Schema.Struct({ ips: Schema.Array(Schema.String).annotate({ description: "IPv4 addresses, empty when the API runs locally." }) }).annotate({ identifier: "EgressIps" });
+var SystemApi = class extends HttpApiGroup.make("system", { topLevel: true }).add(HttpApiEndpoint.get("health", "/health", { success: HttpApiSchema.NoContent }).annotateMerge(OpenApi.annotations({
+	summary: "Check health",
+	description: "Returns 204 when the API is up. No Agent Runner key required."
+}))).add(HttpApiEndpoint.get("egressIps", "/egress-ips", { success: EgressIps }).annotateMerge(OpenApi.annotations({
+	summary: "List egress IPs",
+	description: "The fixed addresses Agent Runner calls MCP servers and their authorization servers from. Allow them on an MCP server that only accepts known addresses. Commands the agent runs in its sandbox, such as cloning the repository, come from other addresses. No Agent Runner key required."
+}))).annotateMerge(OpenApi.annotations({ title: "System" })) {};
+//#endregion
+//#region ../contract/src/api.ts
+var Api = class extends HttpApi.make("agent-runner").add(RunsApi).add(ConnectionsApi).prefix("/v1").add(SystemApi).annotate(HttpApi.ParseOptions, { errors: "all" }).annotateMerge(OpenApi.annotations({
+	title: "Agent Runner API",
+	description: "Run coding agents such as Claude Code in isolated sandboxes. Create a run with a prompt, then follow its output and what it costs."
+})) {};
+//#endregion
+//#region ../contract/src/client.ts
+const CLI_USER_AGENT = "tracks";
+var ApiClient = class ApiClient extends Context.Service()("@tracks/contract/ApiClient") {
+	static layer = (options) => Layer.effect(ApiClient, HttpApiClient.make(Api, { transformClient: HttpClient.mapRequest((request) => {
+		const located = HttpClientRequest.prependUrl(request, options.baseUrl.href);
+		return options.userAgent === void 0 ? located : HttpClientRequest.setHeader(located, "user-agent", options.userAgent);
+	}) })).pipe(Layer.provide(HttpApiMiddleware.layerClient(Authorization, ({ next, request }) => next(HttpClientRequest.bearerToken(request, Redacted.value(options.agentRunnerKey)).pipe(HttpClientRequest.setHeader(ORGANIZATION_HEADER, options.organization))))));
+};
+//#endregion
+//#region ../env/src/env.ts
+const Secret = Schema.Redacted(Schema.NonEmptyString);
+const AgentRunnerKey = Schema.Redacted(Schema.NonEmptyString.check(Schema.isMinLength(32)));
+const Port = Schema.Int.check(Schema.isBetween({
+	minimum: 1,
+	maximum: 65535
+}));
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+const AGENT_RUNNER_PATH = "/agent-runner";
+const SecureUrl = Schema.URLFromString.check(Schema.makeFilter((url) => url.protocol === "https:" || LOOPBACK_HOSTS.has(url.hostname) || "must use https"));
+const ENCRYPTION_KEY_BYTES = 32;
+const EncryptionKey = Schema.Redacted(Schema.NonEmptyString.check(Schema.makeFilter((key) => Buffer.from(key, "base64").length === ENCRYPTION_KEY_BYTES || `must be ${ENCRYPTION_KEY_BYTES} random bytes in base64: openssl rand -base64 ${ENCRYPTION_KEY_BYTES}`)));
+const Origin = Schema.String.check(Schema.makeFilter((origin) => URL.parse(origin)?.origin === origin || `${origin} must be an origin, such as https://app.example.com`));
+const Origins = Schema.String.pipe(Schema.decodeTo(Schema.Array(Origin), SchemaTransformation.transform({
+	decode: (list) => list.split(",").map((origin) => origin.trim()).filter((origin) => origin !== ""),
+	encode: (origins) => origins.join(",")
+})));
+const IpAddresses = Schema.String.pipe(Schema.decodeTo(Schema.Array(Schema.String.check(Schema.makeFilter((address) => isIPv4(address) || `${address} must be an IPv4 address`))), SchemaTransformation.transform({
+	decode: (list) => list.split(",").map((address) => address.trim()).filter((address) => address !== ""),
+	encode: (addresses) => addresses.join(",")
+})));
+const SentryDsn = Schema.URLFromString.check(Schema.makeFilter((url) => url.protocol === "https:" && url.username !== "" || "must be a Sentry DSN"));
+const Secrets = Schema.Struct({
+	AGENT_RUNNER_KEY: AgentRunnerKey,
+	DAYTONA_API_KEY: Secret,
+	E2B_API_KEY: Secret,
+	ANTHROPIC_API_KEY: Secret,
+	OPENAI_API_KEY: Secret,
+	TYPESAFE_API_KEY: Secret,
+	DATABASE_PASSWORD: Secret,
+	CONNECTION_ENCRYPTION_KEY: EncryptionKey,
+	SENTRY_DSN: Schema.optionalKey(Schema.Redacted(SentryDsn))
+});
+const Variables = Schema.Struct({
+	PORT: Port.pipe(Schema.withDecodingDefaultKey(Effect.succeed(3e3))),
+	AGENT_RUNNER_ORGANIZATION: Schema.NonEmptyString,
+	AGENT_RUNNER_API_URL: Schema.URLFromString.pipe(Schema.withDecodingDefaultKey(Effect.succeed(`https://agent-runner.lab.alpic.ai${AGENT_RUNNER_PATH}`))),
+	DAYTONA_API_URL: Schema.NonEmptyString.pipe(Schema.withDecodingDefaultKey(Effect.succeed("https://app.daytona.io/api"))),
+	AGENT_RUNNER_URL: SecureUrl,
+	CONNECTION_RETURN_ORIGINS: Origins.pipe(Schema.withDecodingDefaultKey(Effect.succeed(""))),
+	EGRESS_IPS: IpAddresses.pipe(Schema.withDecodingDefaultKey(Effect.succeed(""))),
+	DATABASE_HOST: Schema.NonEmptyString,
+	DATABASE_PORT: Port.pipe(Schema.withDecodingDefaultKey(Effect.succeed(5432))),
+	DATABASE_NAME: Schema.NonEmptyString.pipe(Schema.withDecodingDefaultKey(Effect.succeed("app"))),
+	DATABASE_USER: Schema.NonEmptyString.pipe(Schema.withDecodingDefaultKey(Effect.succeed("app"))),
+	DATABASE_SSL: Schema.Boolean,
+	LOG_FORMAT: Schema.Literals(["pretty", "json"]).pipe(Schema.withDecodingDefaultKey(Effect.succeed("pretty"))),
+	LOG_LEVEL: Schema.Literals([
+		"Trace",
+		"Debug",
+		"Info",
+		"Warn",
+		"Error",
+		"Fatal"
+	]).pipe(Schema.withDecodingDefaultKey(Effect.succeed("Info"))),
+	DEPLOYMENT_ENVIRONMENT: Schema.NonEmptyString.pipe(Schema.withDecodingDefaultKey(Effect.succeed("local"))),
+	OTLP_METRICS_URL: Schema.optionalKey(Schema.URLFromString)
+});
+const Env = Schema.Struct({
+	...Secrets.fields,
+	...Variables.fields
+});
+const isSecret = (name) => Object.hasOwn(Secrets.fields, name);
+Struct.keys(Env.fields);
+const DATABASE_ENV = [
+	"DATABASE_HOST",
+	"DATABASE_PORT",
+	"DATABASE_NAME",
+	"DATABASE_USER",
+	"DATABASE_PASSWORD",
+	"DATABASE_SSL"
+];
+const DAYTONA_ENV = ["DAYTONA_API_KEY", "DAYTONA_API_URL"];
+const E2B_ENV = ["E2B_API_KEY"];
+const GATEWAY_ENV = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"];
+const CONNECTIONS_ENV = [
+	"AGENT_RUNNER_URL",
+	"CONNECTION_RETURN_ORIGINS",
+	"CONNECTION_ENCRYPTION_KEY"
+];
+const AGENT_RUNNER_ENV = [
+	...DATABASE_ENV,
+	...DAYTONA_ENV,
+	...E2B_ENV,
+	...GATEWAY_ENV,
+	...CONNECTIONS_ENV
+];
+const LOG_ENV = ["LOG_FORMAT", "LOG_LEVEL"];
+const OBSERVABILITY_ENV = [
+	"SENTRY_DSN",
+	"DEPLOYMENT_ENVIRONMENT",
+	"OTLP_METRICS_URL"
+];
+const SERVICE_ENV = [
+	"AGENT_RUNNER_KEY",
+	"PORT",
+	"EGRESS_IPS",
+	...LOG_ENV,
+	...OBSERVABILITY_ENV,
+	...AGENT_RUNNER_ENV
+];
+const CLI_ENV = [
+	"AGENT_RUNNER_KEY",
+	"AGENT_RUNNER_ORGANIZATION",
+	"AGENT_RUNNER_API_URL"
+];
+const isDatabaseVariable = (name) => DATABASE_ENV.some((databaseName) => databaseName === name);
+SERVICE_ENV.flatMap((name) => isSecret(name) && !isDatabaseVariable(name) ? [name] : []);
+const readEnv = (...names) => Config.schema(Env.mapFields(Struct.pick(names)));
+//#endregion
+//#region package.json
+var version = "0.4.0";
+//#endregion
+//#region src/connections.ts
+const encodeConnection = Schema.encodeEffect(Schema.fromJsonString(Connection, { space: 2 }));
+const encodeConnections = Schema.encodeEffect(Schema.fromJsonString(List(Connection), { space: 2 }));
+const connectionId = Argument.String("id").pipe(Argument.withDescription("Connection id"), Argument.withSchema(ConnectionId));
+const LOOPBACK = "127.0.0.1";
+const CALLBACK_PATH = "/callback";
+const CONSENT_TIMEOUT = "10 minutes";
+const RETURNED_PAGE = "<!doctype html><title>Agent Runner</title><p>Back to your terminal: you can close this tab.</p>";
+var ConsentFailed = class extends Schema.TaggedError()("ConsentFailed", { reason: Schema.String }) {
+	get message() {
+		return `The connection did not complete: ${this.reason}`;
+	}
+};
+const listening = (server) => Effect.callback((resume) => {
+	server.listen(0, LOOPBACK, () => {
+		const address = server.address();
+		resume(address !== null && typeof address === "object" ? Effect.succeed(address.port) : Effect.die("The callback server has no port"));
+	});
+});
+const closed = (server) => Effect.callback((resume) => {
+	server.closeAllConnections();
+	server.close(() => resume(Effect.void));
+});
+const loopbackCallback = Effect.gen(function* () {
+	const returned = yield* Deferred.make();
+	const server = createServer((request, response) => {
+		const url = new URL(request.url ?? "/", `http://${LOOPBACK}`);
+		if (url.pathname !== CALLBACK_PATH) {
+			response.writeHead(404).end();
+			return;
+		}
+		response.writeHead(200, { "content-type": "text/html; charset=utf-8" }).end(RETURNED_PAGE);
+		Deferred.doneUnsafe(returned, Effect.succeed(url.searchParams));
+	});
+	const port = yield* Effect.acquireRelease(listening(server), () => closed(server));
+	return {
+		url: `http://${LOOPBACK}:${port}${CALLBACK_PATH}`,
+		returned: Deferred.await(returned)
+	};
+});
+const BROWSER_OPENERS = {
+	darwin: (url) => ChildProcess.make("open", [url]),
+	linux: (url) => ChildProcess.make("xdg-open", [url]),
+	win32: (url) => ChildProcess.make("cmd", [
+		"/c",
+		"start",
+		"\"\"",
+		url
+	])
+};
+const openInBrowser = Effect.fnUntraced(function* (url) {
+	const opener = BROWSER_OPENERS[process.platform];
+	if (opener === void 0) return;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	yield* Effect.ignore(spawner.exitCode(opener(url)));
+});
+const confirmationOf = (params, id) => {
+	if (params.get("connection_id") !== id) return Effect.fail(new ConsentFailed({ reason: "the browser came back for another connection" }));
+	return Option.match(Option.fromNullOr(params.get("confirmation")), {
+		onSome: Effect.succeed,
+		onNone: () => Effect.fail(new ConsentFailed({ reason: params.get("error") ?? "no confirmation came back" }))
+	});
+};
+const add = Command.make("add", { server: Argument.String("server-url").pipe(Argument.withDescription("URL of the MCP server, in https")) }, Effect.fn("connections.add")(function* ({ server }) {
+	const client = yield* ApiClient;
+	const callback = yield* loopbackCallback;
+	const created = yield* client.connections.create({ payload: {
+		server_url: server,
+		return_url: Option.some(callback.url)
+	} });
+	yield* Console.error(`Consent in your browser, opening: ${created.consent_url}`);
+	yield* openInBrowser(created.consent_url);
+	const returned = yield* callback.returned.pipe(Effect.timeoutOrElse({
+		duration: CONSENT_TIMEOUT,
+		orElse: () => Effect.fail(new ConsentFailed({ reason: "no consent within 10 minutes" }))
+	}));
+	const confirmation = yield* confirmationOf(returned, created.connection.id);
+	const connection = yield* client.connections.confirm({
+		params: { id: created.connection.id },
+		payload: { confirmation }
+	});
+	yield* Console.log(yield* encodeConnection(connection));
+}, Effect.scoped)).pipe(Command.withDescription("Connect to an MCP server as one of its users: consent in your browser, then use the connection in runs"));
+const list = Command.make("list", {}, Effect.fn("connections.list")(function* () {
+	const client = yield* ApiClient;
+	yield* Console.log(yield* encodeConnections(yield* client.connections.list()));
+})).pipe(Command.withDescription("List connections"));
+const get$1 = Command.make("get", { id: connectionId }, Effect.fn("connections.get")(function* ({ id }) {
+	const client = yield* ApiClient;
+	yield* Console.log(yield* encodeConnection(yield* client.connections.get({ params: { id } })));
+})).pipe(Command.withDescription("Show a connection"));
+const remove = Command.make("remove", { id: connectionId }, Effect.fn("connections.remove")(function* ({ id }) {
+	yield* (yield* ApiClient).connections.delete({ params: { id } });
+})).pipe(Command.withDescription("Delete a connection and the access it holds"));
+const connections = Command.make("connections").pipe(Command.withDescription("Manage connections to MCP servers"), Command.withSubcommands([
+	add,
+	list,
+	get$1,
+	remove
+]));
+//#endregion
+//#region src/runs.ts
+const encodeRun = Schema.encodeEffect(Schema.fromJsonString(Run, { space: 2 }));
+const encodeFrames = Schema.encodeEffect(Schema.fromJsonString(List(Frame), { space: 2 }));
+const encodeEvents = Schema.encodeEffect(Schema.fromJsonString(List(Event), { space: 2 }));
+const encodeFrame = Schema.encodeEffect(Schema.fromJsonString(Frame));
+const encodeEvent = Schema.encodeEffect(Schema.fromJsonString(Event));
+const encodeUsage = Schema.encodeEffect(Schema.fromJsonString(RunUsage, { space: 2 }));
+const encodePrompt = Schema.encodeEffect(Schema.fromJsonString(Prompt, { space: 2 }));
+const encodePrompts = Schema.encodeEffect(Schema.fromJsonString(List(Prompt), { space: 2 }));
+const runId = Argument.String("id").pipe(Argument.withDescription("Run id"), Argument.withSchema(RunId));
+const variableOf = (entry) => {
+	const equals = entry.indexOf("=");
+	if (equals !== -1) return Option.some({
+		name: entry.slice(0, equals),
+		value: entry.slice(equals + 1)
+	});
+	return Option.map(Option.fromUndefinedOr(process.env[entry]), (value) => ({
+		name: entry,
+		value
+	}));
+};
+const mcpServerOf = (entry) => {
+	const equals = entry.indexOf("=");
+	if (equals === -1) return Option.none();
+	const name = entry.slice(0, equals);
+	const target = entry.slice(equals + 1);
+	return Option.some(URL.canParse(target) ? {
+		name,
+		url: target
+	} : {
+		name,
+		connection_id: ConnectionId.make(target)
+	});
+};
+const create = Command.make("create", {
+	prompt: Argument.String("prompt").pipe(Argument.withDescription("Prompt sent to the agent")),
+	harness: Flag.Literals("harness", Harness.literals).pipe(Flag.withAlias("H"), Flag.withDescription("Harness running the agent")),
+	model: Flag.String("model").pipe(Flag.withAlias("m"), Flag.withDescription("Model used by the harness")),
+	repository: Flag.String("repository").pipe(Flag.withAlias("r"), Flag.withDescription("Git repository cloned into the sandbox"), Flag.optional),
+	env: Flag.String("env").pipe(Flag.withAlias("e"), Flag.withDescription("Environment variable set in the agent's processes, as KEY=VALUE, or KEY to pass its local value"), Flag.filterMap(variableOf, (entry) => `${entry} is not set in the local environment`), Flag.atLeast(0)),
+	setup: Flag.String("setup").pipe(Flag.withDescription("Shell script run in the sandbox after checkout, before the first prompt; from a file: --setup \"$(cat setup.sh)\""), Flag.optional),
+	teardown: Flag.String("teardown").pipe(Flag.withDescription("Shell script run in the sandbox after the run ends, before the sandbox is destroyed; from a file: --teardown \"$(cat teardown.sh)\""), Flag.optional),
+	mcp: Flag.String("mcp").pipe(Flag.withDescription("MCP server the agent can use, as NAME=URL, through your connection to that URL if you have one, or NAME=CONNECTION_ID"), Flag.filterMap(mcpServerOf, (entry) => `${entry} is not NAME=URL or NAME=CONNECTION_ID`), Flag.atLeast(0)),
+	budget: Flag.Finite("budget").pipe(Flag.withAlias("b"), Flag.withDescription("Most the run may spend, in US dollars"), Flag.optional),
+	oneShot: Flag.Boolean("one-shot").pipe(Flag.withDescription("End the run once its first prompt finishes (default); --no-one-shot waits for follow-ups"), Flag.optional),
+	idleTimeout: Flag.Int("idle-timeout").pipe(Flag.withDescription("Seconds an idle run waits for a follow-up before it ends"), Flag.optional),
+	timeLimit: Flag.Int("time-limit").pipe(Flag.withDescription("Longest the run may last, in seconds, before it is stopped"), Flag.optional),
+	idempotencyKey: Flag.String("idempotency-key").pipe(Flag.withDescription("Retry safely: running again with the same key returns the run already created"), Flag.optional)
+}, Effect.fn("runs.create")(function* ({ prompt, harness, model, repository, env, setup, teardown, mcp, budget, oneShot, idleTimeout, timeLimit, idempotencyKey }) {
+	const run = yield* (yield* ApiClient).runs.create({
+		headers: { "idempotency-key": idempotencyKey },
+		payload: {
+			agent: {
+				harness,
+				model
+			},
+			prompt,
+			environment: {
+				repository,
+				variables: Option.some(Object.fromEntries(env.map(({ name, value }) => [name, value]))),
+				setup,
+				teardown,
+				mcp_servers: Option.some(mcp)
+			},
+			budget_usd: budget,
+			one_shot: oneShot,
+			idle_timeout_seconds: idleTimeout,
+			time_limit_seconds: timeLimit
+		}
+	});
+	yield* Console.log(yield* encodeRun(run));
+})).pipe(Command.withDescription("Start a run"));
+const get = Command.make("get", { id: runId }, Effect.fn("runs.get")(function* ({ id }) {
+	const run = yield* (yield* ApiClient).runs.get({ params: { id } });
+	yield* Console.log(yield* encodeRun(run));
+})).pipe(Command.withDescription("Show a run"));
+const usage = Command.make("usage", { id: runId }, Effect.fn("runs.usage")(function* ({ id }) {
+	const client = yield* ApiClient;
+	yield* Console.log(yield* encodeUsage(yield* client.runs.getUsage({ params: { id } })));
+})).pipe(Command.withDescription("Show what a run consumed and what it cost"));
+const frames = Command.make("frames", {
+	id: runId,
+	after: Flag.Int("after").pipe(Flag.withAlias("a"), Flag.withDescription("Only frames with a greater seq"), Flag.optional),
+	limit: Flag.Int("limit").pipe(Flag.withAlias("l"), Flag.withDescription("Maximum frames returned"), Flag.optional),
+	prompt: Flag.Int("prompt").pipe(Flag.withAlias("p"), Flag.withDescription("Only frames of this prompt, by index"), Flag.optional)
+}, Effect.fn("runs.frames")(function* ({ id, after, limit, prompt }) {
+	const page = yield* (yield* ApiClient).runs.listFrames({
+		params: { id },
+		query: {
+			after,
+			limit,
+			prompt
+		}
+	});
+	yield* Console.log(yield* encodeFrames(page));
+})).pipe(Command.withDescription("List a run's frames"));
+const events = Command.make("events", {
+	id: runId,
+	after: Flag.Int("after").pipe(Flag.withAlias("a"), Flag.withDescription("Only events with a greater seq"), Flag.optional),
+	limit: Flag.Int("limit").pipe(Flag.withAlias("l"), Flag.withDescription("Maximum events returned"), Flag.optional),
+	prompt: Flag.Int("prompt").pipe(Flag.withAlias("p"), Flag.withDescription("Only events of this prompt, by index"), Flag.optional)
+}, Effect.fn("runs.events")(function* ({ id, after, limit, prompt }) {
+	const page = yield* (yield* ApiClient).runs.listEvents({
+		params: { id },
+		query: {
+			after,
+			limit,
+			prompt
+		}
+	});
+	yield* Console.log(yield* encodeEvents(page));
+})).pipe(Command.withDescription("List a run's events"));
+const printed = (sent, itemOf, encode) => sent.pipe(Stream.filterMap(itemOf), Stream.tap((item) => Effect.flatMap(encode(item), Console.log)), Stream.map((item) => item.seq), Stream.runLast);
+const follow = Command.make("follow", {
+	id: runId,
+	after: Flag.Int("after").pipe(Flag.withAlias("a"), Flag.withDescription("Only frames, or events with --events, with a greater seq"), Flag.optional),
+	events: Flag.Boolean("events").pipe(Flag.withAlias("e"), Flag.withDescription("Follow the run's events instead of its frames"), Flag.withDefault(false))
+}, Effect.fn("runs.follow")(function* ({ id, after, events: followingEvents }) {
+	const client = yield* ApiClient;
+	const followOnce = (afterSeq) => followingEvents ? Effect.flatMap(client.runs.followEvents({
+		params: { id },
+		query: { after: afterSeq }
+	}), (sent) => printed(sent, (item) => item.event === "event" ? Result.succeed(item.data) : Result.failVoid, encodeEvent)) : Effect.flatMap(client.runs.followFrames({
+		params: { id },
+		query: { after: afterSeq }
+	}), (sent) => printed(sent, (item) => item.event === "frame" ? Result.succeed(item.data) : Result.failVoid, encodeFrame));
+	let lastSeen = after;
+	while (true) {
+		lastSeen = Option.orElse(yield* followOnce(lastSeen), () => lastSeen);
+		if ((yield* client.runs.get({ params: { id } })).status === "ended") return;
+	}
+})).pipe(Command.withDescription("Print a run's frames, or its events with --events, as they come, one JSON object per line, until the run ends"));
+const submitPrompt = Command.make("prompt", {
+	id: runId,
+	text: Argument.String("text").pipe(Argument.withDescription("Follow-up prompt sent to the agent")),
+	model: Flag.String("model").pipe(Flag.withAlias("m"), Flag.withDescription("Model for this prompt only"), Flag.optional)
+}, Effect.fn("runs.prompt")(function* ({ id, text, model }) {
+	const prompt = yield* (yield* ApiClient).runs.submitPrompt({
+		params: { id },
+		payload: {
+			text,
+			model
+		}
+	});
+	yield* Console.log(yield* encodePrompt(prompt));
+})).pipe(Command.withDescription("Send a follow-up prompt to an idle run"));
+const prompts = Command.make("prompts", {
+	id: runId,
+	after: Flag.Int("after").pipe(Flag.withAlias("a"), Flag.withDescription("Only prompts with a greater index"), Flag.optional),
+	limit: Flag.Int("limit").pipe(Flag.withAlias("l"), Flag.withDescription("Maximum prompts returned"), Flag.optional)
+}, Effect.fn("runs.prompts")(function* ({ id, after, limit }) {
+	const page = yield* (yield* ApiClient).runs.listPrompts({
+		params: { id },
+		query: {
+			after,
+			limit
+		}
+	});
+	yield* Console.log(yield* encodePrompts(page));
+})).pipe(Command.withDescription("List a run's prompts"));
+const end = Command.make("end", { id: runId }, Effect.fn("runs.end")(function* ({ id }) {
+	const client = yield* ApiClient;
+	yield* Console.log(yield* encodeRun(yield* client.runs.end({ params: { id } })));
+})).pipe(Command.withDescription("End a run once its current prompt finishes"));
+const cancel = Command.make("cancel", { id: runId }, Effect.fn("runs.cancel")(function* ({ id }) {
+	const client = yield* ApiClient;
+	yield* Console.log(yield* encodeRun(yield* client.runs.cancel({ params: { id } })));
+})).pipe(Command.withDescription("Stop a run right away, even mid-prompt"));
+const runs = Command.make("runs").pipe(Command.withDescription("Manage runs"), Command.withSubcommands([
+	create,
+	get,
+	submitPrompt,
+	prompts,
+	frames,
+	events,
+	follow,
+	usage,
+	end,
+	cancel
+]));
+//#endregion
+//#region src/main.ts
+const health = Command.make("health", {}, Effect.fn("health")(function* () {
+	yield* (yield* ApiClient).health();
+	yield* Console.log("ok");
+})).pipe(Command.withDescription("Check that the API is reachable"));
+const cli = Command.make("tracks").pipe(Command.withDescription("Run coding agents in sandboxes"), Command.withSubcommands([
+	health,
+	runs,
+	connections
+]));
+const ApiClientLayer = Layer.unwrap(Effect.map(readEnv(...CLI_ENV), (env) => ApiClient.layer({
+	baseUrl: env.AGENT_RUNNER_API_URL,
+	agentRunnerKey: env.AGENT_RUNNER_KEY,
+	organization: env.AGENT_RUNNER_ORGANIZATION,
+	userAgent: `${CLI_USER_AGENT}/${version}`
+}))).pipe(Layer.provide(FetchHttpClient.layer));
+const MainLayer = Layer.mergeAll(ApiClientLayer, NodeServices.layer);
+Command.run(cli, { version }).pipe(Effect.provide(MainLayer), NodeRuntime.runMain);
+//#endregion
+export {};

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@alpic-ai/tracks",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.4.0",
+  "description": "Run coding agents in sandboxes from the command line",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alpic-ai/tracks.git",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "tracks": "./dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@effect/platform-node": "^4.0.2",
+    "effect": "^4.0.2"
+  },
+  "devDependencies": {
+    "@tracks/contract": "0.0.0",
+    "@tracks/env": "0.0.0",
+    "rolldown": "^1.2.13"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "start": "node --import @tracks/env/preload src/main.ts",
+    "build": "rolldown --config rolldown.config.ts"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.