@alpic-ai/tracks 0.4.0 → 0.4.2

package/dist/main.js

@@ -7,17 +7,16 @@ 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 }, {
+Context.Service()("@tracks/contract/RequestOrganization");
+Context.Service()("@tracks/contract/CurrentApiKey");
+var ApiKeyRefused = class extends Schema.TaggedError()("ApiKeyRefused", { message: Schema.String }, {
 	httpApiStatus: 401,
-	description: `The Agent Runner key is missing or invalid, or no \`${ORGANIZATION_HEADER}\` header names the Organization.`
+	description: "The API key is missing, malformed or revoked, or its organization is closed."
 }) {};
-var Authorization = class extends HttpApiMiddleware.Service()("@tracks/contract/Authorization", {
+var ApiKeyAuthorization = class extends HttpApiMiddleware.Service()("@tracks/contract/ApiKeyAuthorization", {
 	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
+	security: { bearer: HttpApiSecurity.http({ scheme: "bearer" }).pipe(HttpApiSecurity.annotate(OpenApi.Description, "An API key of your organization, starting with `trk_`, sent as `Authorization: Bearer <key>`.")) },
+	error: ApiKeyRefused
 }) {};
 const OptionalQueryParam = (schema, description) => Schema.optionalKey(schema).annotateKey({ description }).pipe(Schema.decodeTo(Schema.Option(Schema.toType(schema)), SchemaTransformation.optionFromOptionalKey()));
 const ListQuery = {
@@ -88,18 +87,18 @@ const Connection = Schema.Union([Schema.Struct({
 }).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." });
+})]).annotate({ description: "Access to an MCP server as one of its users, kept by us." });
 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."
+	description: "No connection with this id exists in your 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."
+	description: "The connection cannot be started: the return URL is not allowed, or the MCP server cannot be authorized in a way we support."
 }) {};
 var ServerUnreachable = class extends Schema.TaggedError()("ServerUnreachable", { message: Schema.String }, {
 	httpApiStatus: 502,
@@ -141,10 +140,10 @@ var ConnectionsApi = class extends HttpApiGroup.make("connections").add(HttpApiE
 }).annotateMerge(OpenApi.annotations({
 	summary: "Delete a connection",
 	description: "Deletes a connection and the access it holds."
-}))).middleware(Authorization).middleware(RequestValidation).annotateMerge(OpenApi.annotations({
+}))).annotateMerge(OpenApi.annotations({
 	title: "Connections",
 	description: "Let agents use MCP servers as one of their users, without their credentials entering the sandbox."
-})) {};
+})).middleware(ApiKeyAuthorization).middleware(RequestValidation) {};
 //#endregion
 //#region ../contract/src/runs.ts
 const RunId = Schema.String.pipe(Schema.brand("RunId")).annotate({
@@ -154,14 +153,15 @@ const RunId = Schema.String.pipe(Schema.brand("RunId")).annotate({
 const Harness = Schema.Literals([
 	"claude-code",
 	"codex",
-	"codex-app"
+	"codex-app",
+	"cursor"
 ]).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)."
+	description: "The coding agent to run: `claude-code` (Claude Code), `codex` (OpenAI's Codex CLI), `codex-app` (the Codex mode of OpenAI's ChatGPT desktop app, with its browser, computer-use and document tools) or `cursor` (Cursor's CLI)."
 });
 const Agent = Schema.Struct({
 	harness: Harness,
-	model: Schema.NonEmptyString.annotate({ description: "Model the agent uses, such as `claude-sonnet-5-5`." })
+	model: Schema.NonEmptyString.annotate({ description: "Model the agent uses, such as `claude-sonnet-5-5`, or a Cursor model id such as `gpt-5.6-luna-low`." })
 }).annotate({
 	identifier: "Agent",
 	description: "The coding agent and the model it uses."
@@ -169,8 +169,8 @@ const Agent = Schema.Struct({
 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 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 after a restart on our side: 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 after a restart on our side: 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 = [
@@ -214,7 +214,7 @@ const McpServerInput = Schema.Union([Schema.Struct({
 	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`."
+	description: "An MCP server the agent can use, reached through us: 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);
@@ -251,6 +251,26 @@ const RunEnvironment = Schema.Struct({
 	identifier: "Environment",
 	description: "What the agent works on."
 });
+const LABEL_KEY_PATTERN = "[A-Za-z0-9_.-]{1,64}";
+const LABEL_KEY = new RegExp(`^${LABEL_KEY_PATTERN}$`);
+const MAX_LABELS = 20;
+const MAX_LABEL_VALUE_LENGTH = 256;
+const Labels = Schema.Record(Schema.String, Schema.String.check(Schema.isMaxLength(MAX_LABEL_VALUE_LENGTH))).annotate({ description: `Labels you attach to the run to find it again, as keys and values, such as \`{ "ticket": "ENG-42" }\`. We never read them. Keys match \`${LABEL_KEY.source}\`; at most ${MAX_LABELS} labels with values of up to ${MAX_LABEL_VALUE_LENGTH} characters.` }).check(Schema.isMaxProperties(MAX_LABELS), Schema.makeFilter((labels) => Object.keys(labels).flatMap((key) => LABEL_KEY.test(key) ? [] : [{
+	path: [key],
+	issue: `Expected a key matching ${LABEL_KEY.source}`
+}])));
+const LABEL_FILTER = new RegExp(`^${LABEL_KEY_PATTERN}:`);
+const keyAndValueOf = (filter) => {
+	const separator = filter.indexOf(":");
+	return [filter.slice(0, separator), filter.slice(separator + 1)];
+};
+const LabelFilters = Schema.Array(Schema.String.check(Schema.isPattern(LABEL_FILTER))).check(Schema.makeFilter((filters) => {
+	const keys = filters.map((filter) => keyAndValueOf(filter)[0]);
+	return new Set(keys).size === keys.length || "Expected each label key once";
+})).pipe(Schema.decodeTo(Labels, SchemaTransformation.transform({
+	decode: (filters) => Object.fromEntries(filters.map(keyAndValueOf)),
+	encode: (labels) => Object.entries(labels).map(([key, value]) => `${key}:${value}`)
+})));
 const Budget = Schema.Finite.check(Schema.isBetween({
 	minimum: .01,
 	maximum: 1e4
@@ -263,6 +283,7 @@ const CreateRunInput = Schema.Struct({
 	agent: Agent,
 	prompt: Schema.NonEmptyString.annotate({ description: "What you ask the agent to do first." }),
 	environment: EnvironmentInput,
+	labels: Schema.optionalKey(Labels),
 	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({
@@ -274,10 +295,10 @@ const CreateRunInput = Schema.Struct({
 		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({
+const SendPromptInput = 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" });
+}).annotate({ identifier: "SendPromptInput" });
 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,
@@ -329,6 +350,7 @@ const FailureKind = Schema.Literals([
 });
 const runFields = {
 	id: RunId,
+	labels: Labels.annotate({ description: "Labels attached to the run when it was created." }),
 	agent: Agent,
 	environment: RunEnvironment,
 	budget_usd: Schema.Number.annotate({ description: "Maximum the run may spend, in US dollars." }),
@@ -380,7 +402,7 @@ const Run = Schema.Union([
 ]).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."
+	description: "No run with this id exists in your organization."
 }) {};
 var ConnectionUnusable = class extends Schema.TaggedError()("ConnectionUnusable", { message: Schema.String }, {
 	httpApiStatus: 422,
@@ -390,6 +412,21 @@ var ModelNotOffered = class extends Schema.TaggedError()("ModelNotOffered", { me
 	httpApiStatus: 422,
 	description: "The agent cannot use this model. The message lists the models it can use."
 }) {};
+var ModelProviderUnavailable = class extends Schema.TaggedError()("ModelProviderUnavailable", { message: Schema.String }, {
+	httpApiStatus: 503,
+	description: "The model provider could not be reached to check the model. Retry later."
+}) {};
+var InsufficientBalance = class extends Schema.TaggedError()("InsufficientBalance", {
+	message: Schema.String,
+	top_up_url: Schema.String.annotate({ description: "Where to add funds to your organization's balance." })
+}, {
+	httpApiStatus: 402,
+	description: "Your organization's balance is $0 or below: add funds to start runs again."
+}) {};
+var OrganizationBlocked = class extends Schema.TaggedError()("OrganizationBlocked", { message: Schema.String }, {
+	httpApiStatus: 403,
+	description: "Your organization cannot start runs after a dispute on one of its payments: contact us."
+}) {};
 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."
@@ -433,7 +470,7 @@ const eventFields = {
 	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." })
+	frame_seqs: Schema.Array(Schema.Int).annotate({ description: "The `seq` of each output line the event was read from. Empty for events we record ourselves." })
 };
 const Event = Schema.Union([
 	Schema.Struct({
@@ -529,14 +566,35 @@ const EventStreamItem = Schema.Union([Schema.Struct({
 	event: Schema.Literal("heartbeat"),
 	data: Schema.Literal("")
 })]);
+const STARTED_BY_LABEL = "started_by";
+const CreateRunInputBesidesStartedBy = CreateRunInput.check(Schema.makeFilter((input) => Object.keys(input.labels ?? {}).filter((key) => key !== STARTED_BY_LABEL).length < MAX_LABELS || {
+	path: ["labels"],
+	issue: `Expected at most 19 labels besides ${STARTED_BY_LABEL}, which is set to the API key`
+}));
 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,
+	payload: CreateRunInputBesidesStartedBy,
 	success: Run.pipe(HttpApiSchema.status(201)),
-	error: [ModelNotOffered, ConnectionUnusable]
+	error: [
+		ModelNotOffered,
+		ModelProviderUnavailable,
+		ConnectionUnusable,
+		InsufficientBalance,
+		OrganizationBlocked
+	]
 }).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."
+	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. The run gets the label \`${STARTED_BY_LABEL}: key:<id>\`, with the id of the API key that created it, in place of any \`${STARTED_BY_LABEL}\` you send. Runs start only while your organization's balance is above $0.`
+})), HttpApiEndpoint.get("list", "/runs", {
+	query: {
+		label: OptionalQueryParam(LabelFilters, "Return only runs with this label, written `key:value`, such as `ticket:ENG-42`. Repeat it to require several labels."),
+		after: OptionalQueryParam(RunId, "Return only runs listed after the run with this id."),
+		limit: ListQuery.limit
+	},
+	success: List(Run)
+}).annotateMerge(OpenApi.annotations({
+	summary: "List runs",
+	description: "Returns your runs, most recently started first. To get the next page, pass the `id` of the last run received as `after`."
 })), HttpApiEndpoint.get("get", "/runs/:id", {
 	params: { id: RunId },
 	success: Run,
@@ -549,7 +607,7 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 	success: RunUsage,
 	error: RunNotFound
 }).annotateMerge(OpenApi.annotations({
-	summary: "Get run usage",
+	summary: "Get a run's 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 },
@@ -565,14 +623,15 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 }).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", {
+})), HttpApiEndpoint.post("sendPrompt", "/runs/:id/prompts", {
 	params: { id: RunId },
-	payload: SubmitPromptInput,
+	payload: SendPromptInput,
 	success: Prompt.pipe(HttpApiSchema.status(202)),
 	error: [
 		RunNotFound,
 		RunNotIdle,
-		ModelNotOffered
+		ModelNotOffered,
+		ModelProviderUnavailable
 	]
 }).annotateMerge(OpenApi.annotations({
 	summary: "Send a follow-up prompt",
@@ -583,7 +642,7 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 	success: List(Prompt),
 	error: RunNotFound
 }).annotateMerge(OpenApi.annotations({
-	summary: "List run prompts",
+	summary: "List a run's 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 },
@@ -594,7 +653,7 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 	success: List(Frame),
 	error: RunNotFound
 }).annotateMerge(OpenApi.annotations({
-	summary: "List run output",
+	summary: "List a run's frames",
 	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 },
@@ -605,7 +664,7 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 	success: List(Event),
 	error: RunNotFound
 }).annotateMerge(OpenApi.annotations({
-	summary: "List run events",
+	summary: "List a run's 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 },
@@ -613,7 +672,7 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 	success: HttpApiSchema.StreamSse({ events: FrameStreamItem }),
 	error: RunNotFound
 }).annotateMerge(OpenApi.annotations({
-	summary: "Stream run output",
+	summary: "Stream a run's frames",
 	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 },
@@ -621,41 +680,42 @@ var RunsApi = class extends HttpApiGroup.make("runs").add(HttpApiEndpoint.post("
 	success: HttpApiSchema.StreamSse({ events: EventStreamItem }),
 	error: RunNotFound
 }).annotateMerge(OpenApi.annotations({
-	summary: "Stream run events",
+	summary: "Stream a run's 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({
+}))).annotateMerge(OpenApi.annotations({
 	title: "Runs",
 	description: "Start coding agents and follow their work."
-})) {};
+})).middleware(ApiKeyAuthorization).middleware(RequestValidation) {};
 //#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."
+	description: "Returns 204 when the API is up. No 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."
+	description: "The fixed addresses we call 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 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."
+var TracksApi = class extends HttpApi.make("tracks").add(RunsApi).add(ConnectionsApi).add(SystemApi).annotate(HttpApi.ParseOptions, { errors: "all" }).annotateMerge(OpenApi.annotations({
+	title: "Tracks API",
+	description: "Run coding agents such as Claude Code in isolated sandboxes with an API key of your organization. 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) => {
+	static layer = (options) => Layer.effect(ApiClient, HttpApiClient.make(TracksApi, { 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))))));
+	}) })).pipe(Layer.provide(HttpApiMiddleware.layerClient(ApiKeyAuthorization, ({ next, request }) => next(HttpClientRequest.bearerToken(request, Redacted.value(options.apiKey))))));
 };
 //#endregion
 //#region ../env/src/env.ts
 const Secret = Schema.Redacted(Schema.NonEmptyString);
 const AgentRunnerKey = Schema.Redacted(Schema.NonEmptyString.check(Schema.isMinLength(32)));
+const StripeKey = (prefix) => Schema.Redacted(Schema.String.check(Schema.isStartingWith(prefix)));
 const Port = Schema.Int.check(Schema.isBetween({
 	minimum: 1,
 	maximum: 65535
@@ -665,7 +725,7 @@ const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
 	"127.0.0.1",
 	"[::1]"
 ]);
-const AGENT_RUNNER_PATH = "/agent-runner";
+const TRACKS_API_PATH = "/api";
 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}`)));
@@ -681,19 +741,23 @@ const IpAddresses = Schema.String.pipe(Schema.decodeTo(Schema.Array(Schema.Strin
 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,
+	TRACKS_API_KEY: Secret,
 	DAYTONA_API_KEY: Secret,
 	E2B_API_KEY: Secret,
 	ANTHROPIC_API_KEY: Secret,
 	OPENAI_API_KEY: Secret,
+	CURSOR_API_KEY: Secret,
+	CURSOR_ADMIN_KEY: Secret,
 	TYPESAFE_API_KEY: Secret,
 	DATABASE_PASSWORD: Secret,
 	CONNECTION_ENCRYPTION_KEY: EncryptionKey,
+	STRIPE_SECRET_KEY: StripeKey("rk_"),
+	STRIPE_WEBHOOK_SECRET: StripeKey("whsec_"),
 	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}`))),
+	TRACKS_API_URL: Schema.URLFromString.pipe(Schema.withDecodingDefaultKey(Effect.succeed(`https://agent-runner.lab.alpic.ai${TRACKS_API_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(""))),
@@ -731,12 +795,18 @@ const DATABASE_ENV = [
 ];
 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 GATEWAY_ENV = [
+	"ANTHROPIC_API_KEY",
+	"OPENAI_API_KEY",
+	"CURSOR_API_KEY",
+	"CURSOR_ADMIN_KEY"
+];
 const CONNECTIONS_ENV = [
 	"AGENT_RUNNER_URL",
 	"CONNECTION_RETURN_ORIGINS",
 	"CONNECTION_ENCRYPTION_KEY"
 ];
+const PAYMENTS_ENV = ["STRIPE_SECRET_KEY", "STRIPE_WEBHOOK_SECRET"];
 const AGENT_RUNNER_ENV = [
 	...DATABASE_ENV,
 	...DAYTONA_ENV,
@@ -756,19 +826,16 @@ const SERVICE_ENV = [
 	"EGRESS_IPS",
 	...LOG_ENV,
 	...OBSERVABILITY_ENV,
-	...AGENT_RUNNER_ENV
-];
-const CLI_ENV = [
-	"AGENT_RUNNER_KEY",
-	"AGENT_RUNNER_ORGANIZATION",
-	"AGENT_RUNNER_API_URL"
+	...AGENT_RUNNER_ENV,
+	...PAYMENTS_ENV
 ];
+const CLI_ENV = ["TRACKS_API_KEY", "TRACKS_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";
+var version = "0.4.2";
 //#endregion
 //#region src/connections.ts
 const encodeConnection = Schema.encodeEffect(Schema.fromJsonString(Connection, { space: 2 }));
@@ -777,7 +844,7 @@ const connectionId = Argument.String("id").pipe(Argument.withDescription("Connec
 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>";
+const RETURNED_PAGE = "<!doctype html><title>Tracks</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}`;
@@ -833,7 +900,7 @@ const confirmationOf = (params, id) => {
 		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 create$1 = Command.make("create", { server: Argument.String("server-url").pipe(Argument.withDescription("URL of the MCP server, in https")) }, Effect.fn("connections.create")(function* ({ server }) {
 	const client = yield* ApiClient;
 	const callback = yield* loopbackCallback;
 	const created = yield* client.connections.create({ payload: {
@@ -861,14 +928,14 @@ const get$1 = Command.make("get", { id: connectionId }, Effect.fn("connections.g
 	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 }) {
+const deleteConnection = Command.make("delete", { id: connectionId }, Effect.fn("connections.delete")(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,
+	create$1,
 	list,
 	get$1,
-	remove
+	deleteConnection
 ]));
 //#endregion
 //#region src/runs.ts
@@ -1003,12 +1070,12 @@ const follow = Command.make("follow", {
 		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", {
+const sendPrompt = Command.make("send-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({
+}, Effect.fn("runs.sendPrompt")(function* ({ id, text, model }) {
+	const prompt = yield* (yield* ApiClient).runs.sendPrompt({
 		params: { id },
 		payload: {
 			text,
@@ -1042,7 +1109,7 @@ const cancel = Command.make("cancel", { id: runId }, Effect.fn("runs.cancel")(fu
 const runs = Command.make("runs").pipe(Command.withDescription("Manage runs"), Command.withSubcommands([
 	create,
 	get,
-	submitPrompt,
+	sendPrompt,
 	prompts,
 	frames,
 	events,
@@ -1063,12 +1130,15 @@ const cli = Command.make("tracks").pipe(Command.withDescription("Run coding agen
 	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,
+	baseUrl: env.TRACKS_API_URL,
+	apiKey: env.TRACKS_API_KEY,
 	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);
+Command.run(cli, { version }).pipe(Effect.catch((error) => {
+	const explainedByHelp = error._tag === "ShowHelp";
+	const line = "message" in error ? `${error._tag}: ${error.message}` : error._tag;
+	return Effect.andThen(explainedByHelp ? Effect.void : Console.error(line), Effect.sync(() => void (process.exitCode = 1)));
+}), Effect.provide(MainLayer), NodeRuntime.runMain);
 //#endregion
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alpic-ai/tracks",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Run coding agents in sandboxes from the command line",
   "license": "UNLICENSED",
   "repository": {