@hasna/switcher 0.1.0

package/dist/harness-types.d.ts

@@ -0,0 +1,24 @@
+import type { Model, Provider, Profile } from "./domain";
+export type HarnessId = Profile["harness"];
+export type HarnessLaunchInput = {
+    harness: HarnessId;
+    baseUrl: string;
+    protocol: Provider["protocol"];
+    authStyle?: Provider["authStyle"];
+    model: string;
+    models: Model[];
+    credential?: string;
+    executable?: string;
+    args?: string[];
+    stateDir: string;
+    cwd: string;
+    version?: string;
+};
+export type PreparedLaunch = {
+    executable: string;
+    args: string[];
+    env: Record<string, string>;
+    configPaths: string[];
+    warnings: string[];
+    cleanup?: () => Promise<void>;
+};

package/dist/harnesses.d.ts

@@ -0,0 +1,13 @@
+import type { HarnessId, HarnessLaunchInput, PreparedLaunch } from "./harness-types";
+export declare function detectHarness(harness: HarnessId, override?: string): Promise<{
+    harness: "claude" | "codex" | "grok" | "opencode2";
+    executable: string;
+    available: boolean;
+    version: string;
+} | {
+    harness: "claude" | "codex" | "grok" | "opencode2";
+    executable: string;
+    available: boolean;
+    version: undefined;
+}>;
+export declare function prepareHarnessLaunch(input: HarnessLaunchInput): Promise<PreparedLaunch>;

package/dist/http.d.ts

@@ -0,0 +1 @@
+export declare function boundedJson(response: Pick<Response, "body">, maxBytes?: number): Promise<any>;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./sdk";

package/dist/index.js

@@ -0,0 +1,227 @@
+// src/domain.ts
+import { z } from "zod";
+var harnessSchema = z.enum(["claude", "codex", "grok", "opencode2"]);
+var protocolSchema = z.enum(["anthropic-messages", "openai-responses", "openai-chat"]);
+var idSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
+var label = z.string().min(1).max(200);
+var envRef = z.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
+function endpoint(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Fault(400, "invalid_url", "Use an absolute HTTPS URL (HTTP is allowed on loopback).");
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local) || url.username || url.password || url.search || url.hash)
+    throw new Fault(400, "invalid_url", "URL must use HTTPS, contain no credentials/query/fragment, or use HTTP on loopback.");
+  return url.href.replace(/\/+$/, "");
+}
+var urlSchema = z.string().max(2000).superRefine((v, ctx) => {
+  try {
+    endpoint(v);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "Invalid endpoint URL" });
+  }
+}).transform(endpoint);
+var modelSchema = z.object({
+  id: z.string().min(1).max(300),
+  name: label,
+  description: z.string().max(8000).optional(),
+  contextWindow: z.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
+  inputModalities: z.array(z.string().max(50)).max(20).optional(),
+  outputModalities: z.array(z.string().max(50)).max(20).optional(),
+  supportedParameters: z.array(z.string().max(100)).max(100).optional()
+}).strict();
+var providerInputSchema = z.object({
+  id: idSchema,
+  name: label,
+  baseUrl: urlSchema,
+  protocol: protocolSchema,
+  credentialEnv: envRef.optional(),
+  authStyle: z.enum(["bearer", "x-api-key"]).default("bearer"),
+  modelsPath: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
+  manualModels: z.array(modelSchema).max(1e4).default([])
+}).strict().refine((p) => !p.modelsPath.split("/").includes("..") && !p.modelsPath.startsWith("/"), "modelsPath must be relative");
+var profileInputSchema = z.object({
+  id: idSchema,
+  name: label,
+  providerId: idSchema,
+  harness: harnessSchema,
+  model: z.string().min(1).max(300)
+}).strict();
+var runInputSchema = z.object({
+  profileId: idSchema,
+  harness: harnessSchema,
+  model: z.string().min(1).max(300),
+  planToken: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var runUpdateSchema = z.object({
+  status: z.enum(["exited", "failed", "interrupted"]),
+  exitCode: z.number().int().min(0).max(255)
+}).strict();
+
+class Fault extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+}
+
+// src/http.ts
+var MAX_BYTES = 16 * 1024 * 1024;
+async function boundedJson(response, maxBytes = MAX_BYTES) {
+  if (!response.body)
+    throw new Fault(502, "invalid_upstream", "Upstream returned no body.");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const item = await reader.read();
+      if (item.done)
+        break;
+      size += item.value.byteLength;
+      if (size > maxBytes)
+        throw new Fault(502, "response_too_large", "Response exceeds the size limit.");
+      chunks.push(item.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    try {
+      return JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      throw new Fault(502, "invalid_upstream", "Upstream returned invalid JSON.");
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+}
+
+// src/sdk.ts
+import { resolveCredential } from "@hasna/contracts/client";
+
+class SwitcherError extends Error {
+  status;
+  code;
+  requestId;
+  constructor(status, code, message, requestId) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+  }
+}
+
+class SwitcherClient {
+  options;
+  baseUrl;
+  constructor(options) {
+    this.baseUrl = endpoint(options.baseUrl).replace(/\/v1$/, "");
+    if (typeof options.apiKey === "string" && (!options.apiKey || /[\r\n]/.test(options.apiKey)))
+      throw new Error("Switcher API key is required.");
+    this.options = { ...options };
+  }
+  async request(method, path, body, options = {}) {
+    if (!/^\/v1\/[a-zA-Z0-9/?&=._%+-]+$/.test(path) || path.includes(".."))
+      throw new Error("Invalid API path.");
+    const apiKey = typeof this.options.apiKey === "function" ? this.options.apiKey() : this.options.apiKey;
+    if (!apiKey || /[\r\n]/.test(apiKey))
+      throw new Error("Switcher API key is required.");
+    const headers = { authorization: `Bearer ${apiKey}`, accept: "application/json" };
+    if (body !== undefined)
+      headers["content-type"] = "application/json";
+    if (method !== "GET")
+      headers["idempotency-key"] = options.idempotencyKey ?? crypto.randomUUID();
+    if (options.version !== undefined)
+      headers["if-match"] = String(options.version);
+    let response;
+    try {
+      response = await (this.options.fetch ?? fetch)(`${this.baseUrl}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(this.options.timeoutMs ?? 120000) });
+    } catch {
+      throw new SwitcherError(0, "connection_failed", "Switcher API request failed; check endpoint and service availability.");
+    }
+    let data;
+    try {
+      data = await boundedJson(response);
+    } catch {
+      throw new SwitcherError(response.status, "invalid_response", "Switcher API returned invalid JSON.");
+    }
+    if (!response.ok)
+      throw new SwitcherError(response.status, data?.error?.code ?? "api_error", data?.error?.message ?? `Switcher API returned HTTP ${response.status}.`, data?.error?.requestId);
+    return data;
+  }
+  query(options = {}) {
+    return new URLSearchParams(Object.entries(options).filter(([, v]) => v !== undefined).map(([k, v]) => [k, String(v)])).toString();
+  }
+  listProviders(options = {}) {
+    return this.request("GET", `/v1/providers?${this.query(options)}`);
+  }
+  getProvider(id) {
+    return this.request("GET", `/v1/providers/${encodeURIComponent(id)}`);
+  }
+  createProvider(input, idempotencyKey) {
+    return this.request("POST", "/v1/providers", input, { idempotencyKey });
+  }
+  updateProvider(input, version, idempotencyKey) {
+    return this.request("PUT", `/v1/providers/${encodeURIComponent(input.id)}`, input, { version, idempotencyKey });
+  }
+  deleteProvider(id, version, idempotencyKey) {
+    return this.request("DELETE", `/v1/providers/${encodeURIComponent(id)}`, undefined, { version, idempotencyKey });
+  }
+  refreshModels(id, idempotencyKey) {
+    return this.request("POST", `/v1/providers/${encodeURIComponent(id)}/refresh`, {}, { idempotencyKey });
+  }
+  listModels(id, options = {}) {
+    return this.request("GET", `/v1/providers/${encodeURIComponent(id)}/models?${this.query(options)}`);
+  }
+  listProfiles(options = {}) {
+    return this.request("GET", `/v1/profiles?${this.query(options)}`);
+  }
+  getProfile(id) {
+    return this.request("GET", `/v1/profiles/${encodeURIComponent(id)}`);
+  }
+  createProfile(input, idempotencyKey) {
+    return this.request("POST", "/v1/profiles", input, { idempotencyKey });
+  }
+  updateProfile(input, version, idempotencyKey) {
+    return this.request("PUT", `/v1/profiles/${encodeURIComponent(input.id)}`, input, { version, idempotencyKey });
+  }
+  deleteProfile(id, version, idempotencyKey) {
+    return this.request("DELETE", `/v1/profiles/${encodeURIComponent(id)}`, undefined, { version, idempotencyKey });
+  }
+  launchPlan(profileId, idempotencyKey) {
+    return this.request("POST", "/v1/launch-plans", { profileId }, { idempotencyKey });
+  }
+  listRuns(options = {}) {
+    return this.request("GET", `/v1/runs?${this.query(options)}`);
+  }
+  getRun(id) {
+    return this.request("GET", `/v1/runs/${encodeURIComponent(id)}`);
+  }
+  createRun(input, idempotencyKey) {
+    return this.request("POST", "/v1/runs", input, { idempotencyKey });
+  }
+  finishRun(id, version, input, idempotencyKey) {
+    return this.request("PATCH", `/v1/runs/${encodeURIComponent(id)}`, input, { version, idempotencyKey });
+  }
+}
+function clientFromEnv(env = process.env) {
+  const credential = () => resolveCredential("switcher", Object.fromEntries(Object.entries(env).filter(([name]) => name === "HASNA_SWITCHER_API_KEY")), { keychain: { enabled: false } })?.apiKey ?? "";
+  if (!env.HASNA_SWITCHER_API_URL || !credential())
+    throw new Error("Set HASNA_SWITCHER_API_URL and HASNA_SWITCHER_API_KEY; no local database fallback is available.");
+  return new SwitcherClient({ baseUrl: env.HASNA_SWITCHER_API_URL, apiKey: credential });
+}
+export {
+  clientFromEnv,
+  SwitcherError,
+  SwitcherClient
+};

package/dist/launcher.d.ts

@@ -0,0 +1,9 @@
+import { SwitcherClient } from "./sdk";
+export declare function childEnvironment(env?: NodeJS.ProcessEnv): Record<string, string>;
+export declare function launch(client: SwitcherClient, profileId: string, options?: {
+    cwd?: string;
+    executable?: string;
+    stateDir?: string;
+    args?: string[];
+    timeoutMs?: number;
+}): Promise<number>;

package/dist/mcp/index.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/mcp.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+
+// src/domain.ts
+import { z } from "zod";
+var VERSION = "0.1.0";
+var harnessSchema = z.enum(["claude", "codex", "grok", "opencode2"]);
+var protocolSchema = z.enum(["anthropic-messages", "openai-responses", "openai-chat"]);
+var idSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
+var label = z.string().min(1).max(200);
+var envRef = z.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
+function endpoint(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Fault(400, "invalid_url", "Use an absolute HTTPS URL (HTTP is allowed on loopback).");
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local) || url.username || url.password || url.search || url.hash)
+    throw new Fault(400, "invalid_url", "URL must use HTTPS, contain no credentials/query/fragment, or use HTTP on loopback.");
+  return url.href.replace(/\/+$/, "");
+}
+var urlSchema = z.string().max(2000).superRefine((v, ctx) => {
+  try {
+    endpoint(v);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "Invalid endpoint URL" });
+  }
+}).transform(endpoint);
+var modelSchema = z.object({
+  id: z.string().min(1).max(300),
+  name: label,
+  description: z.string().max(8000).optional(),
+  contextWindow: z.number().int().positive().optional(),
+  maxOutputTokens: z.number().int().positive().optional(),
+  inputModalities: z.array(z.string().max(50)).max(20).optional(),
+  outputModalities: z.array(z.string().max(50)).max(20).optional(),
+  supportedParameters: z.array(z.string().max(100)).max(100).optional()
+}).strict();
+var providerInputSchema = z.object({
+  id: idSchema,
+  name: label,
+  baseUrl: urlSchema,
+  protocol: protocolSchema,
+  credentialEnv: envRef.optional(),
+  authStyle: z.enum(["bearer", "x-api-key"]).default("bearer"),
+  modelsPath: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
+  manualModels: z.array(modelSchema).max(1e4).default([])
+}).strict().refine((p) => !p.modelsPath.split("/").includes("..") && !p.modelsPath.startsWith("/"), "modelsPath must be relative");
+var profileInputSchema = z.object({
+  id: idSchema,
+  name: label,
+  providerId: idSchema,
+  harness: harnessSchema,
+  model: z.string().min(1).max(300)
+}).strict();
+var runInputSchema = z.object({
+  profileId: idSchema,
+  harness: harnessSchema,
+  model: z.string().min(1).max(300),
+  planToken: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var runUpdateSchema = z.object({
+  status: z.enum(["exited", "failed", "interrupted"]),
+  exitCode: z.number().int().min(0).max(255)
+}).strict();
+
+class Fault extends Error {
+  status;
+  code;
+  constructor(status, code, message) {
+    super(message);
+    this.status = status;
+    this.code = code;
+  }
+}
+
+// src/http.ts
+var MAX_BYTES = 16 * 1024 * 1024;
+async function boundedJson(response, maxBytes = MAX_BYTES) {
+  if (!response.body)
+    throw new Fault(502, "invalid_upstream", "Upstream returned no body.");
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  try {
+    while (true) {
+      const item = await reader.read();
+      if (item.done)
+        break;
+      size += item.value.byteLength;
+      if (size > maxBytes)
+        throw new Fault(502, "response_too_large", "Response exceeds the size limit.");
+      chunks.push(item.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    try {
+      return JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      throw new Fault(502, "invalid_upstream", "Upstream returned invalid JSON.");
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+}
+
+// src/sdk.ts
+import { resolveCredential } from "@hasna/contracts/client";
+
+class SwitcherError extends Error {
+  status;
+  code;
+  requestId;
+  constructor(status, code, message, requestId) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.requestId = requestId;
+  }
+}
+
+class SwitcherClient {
+  options;
+  baseUrl;
+  constructor(options) {
+    this.baseUrl = endpoint(options.baseUrl).replace(/\/v1$/, "");
+    if (typeof options.apiKey === "string" && (!options.apiKey || /[\r\n]/.test(options.apiKey)))
+      throw new Error("Switcher API key is required.");
+    this.options = { ...options };
+  }
+  async request(method, path, body, options = {}) {
+    if (!/^\/v1\/[a-zA-Z0-9/?&=._%+-]+$/.test(path) || path.includes(".."))
+      throw new Error("Invalid API path.");
+    const apiKey = typeof this.options.apiKey === "function" ? this.options.apiKey() : this.options.apiKey;
+    if (!apiKey || /[\r\n]/.test(apiKey))
+      throw new Error("Switcher API key is required.");
+    const headers = { authorization: `Bearer ${apiKey}`, accept: "application/json" };
+    if (body !== undefined)
+      headers["content-type"] = "application/json";
+    if (method !== "GET")
+      headers["idempotency-key"] = options.idempotencyKey ?? crypto.randomUUID();
+    if (options.version !== undefined)
+      headers["if-match"] = String(options.version);
+    let response;
+    try {
+      response = await (this.options.fetch ?? fetch)(`${this.baseUrl}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body), redirect: "manual", signal: AbortSignal.timeout(this.options.timeoutMs ?? 120000) });
+    } catch {
+      throw new SwitcherError(0, "connection_failed", "Switcher API request failed; check endpoint and service availability.");
+    }
+    let data;
+    try {
+      data = await boundedJson(response);
+    } catch {
+      throw new SwitcherError(response.status, "invalid_response", "Switcher API returned invalid JSON.");
+    }
+    if (!response.ok)
+      throw new SwitcherError(response.status, data?.error?.code ?? "api_error", data?.error?.message ?? `Switcher API returned HTTP ${response.status}.`, data?.error?.requestId);
+    return data;
+  }
+  query(options = {}) {
+    return new URLSearchParams(Object.entries(options).filter(([, v]) => v !== undefined).map(([k, v]) => [k, String(v)])).toString();
+  }
+  listProviders(options = {}) {
+    return this.request("GET", `/v1/providers?${this.query(options)}`);
+  }
+  getProvider(id) {
+    return this.request("GET", `/v1/providers/${encodeURIComponent(id)}`);
+  }
+  createProvider(input, idempotencyKey) {
+    return this.request("POST", "/v1/providers", input, { idempotencyKey });
+  }
+  updateProvider(input, version, idempotencyKey) {
+    return this.request("PUT", `/v1/providers/${encodeURIComponent(input.id)}`, input, { version, idempotencyKey });
+  }
+  deleteProvider(id, version, idempotencyKey) {
+    return this.request("DELETE", `/v1/providers/${encodeURIComponent(id)}`, undefined, { version, idempotencyKey });
+  }
+  refreshModels(id, idempotencyKey) {
+    return this.request("POST", `/v1/providers/${encodeURIComponent(id)}/refresh`, {}, { idempotencyKey });
+  }
+  listModels(id, options = {}) {
+    return this.request("GET", `/v1/providers/${encodeURIComponent(id)}/models?${this.query(options)}`);
+  }
+  listProfiles(options = {}) {
+    return this.request("GET", `/v1/profiles?${this.query(options)}`);
+  }
+  getProfile(id) {
+    return this.request("GET", `/v1/profiles/${encodeURIComponent(id)}`);
+  }
+  createProfile(input, idempotencyKey) {
+    return this.request("POST", "/v1/profiles", input, { idempotencyKey });
+  }
+  updateProfile(input, version, idempotencyKey) {
+    return this.request("PUT", `/v1/profiles/${encodeURIComponent(input.id)}`, input, { version, idempotencyKey });
+  }
+  deleteProfile(id, version, idempotencyKey) {
+    return this.request("DELETE", `/v1/profiles/${encodeURIComponent(id)}`, undefined, { version, idempotencyKey });
+  }
+  launchPlan(profileId, idempotencyKey) {
+    return this.request("POST", "/v1/launch-plans", { profileId }, { idempotencyKey });
+  }
+  listRuns(options = {}) {
+    return this.request("GET", `/v1/runs?${this.query(options)}`);
+  }
+  getRun(id) {
+    return this.request("GET", `/v1/runs/${encodeURIComponent(id)}`);
+  }
+  createRun(input, idempotencyKey) {
+    return this.request("POST", "/v1/runs", input, { idempotencyKey });
+  }
+  finishRun(id, version, input, idempotencyKey) {
+    return this.request("PATCH", `/v1/runs/${encodeURIComponent(id)}`, input, { version, idempotencyKey });
+  }
+}
+function clientFromEnv(env = process.env) {
+  const credential = () => resolveCredential("switcher", Object.fromEntries(Object.entries(env).filter(([name]) => name === "HASNA_SWITCHER_API_KEY")), { keychain: { enabled: false } })?.apiKey ?? "";
+  if (!env.HASNA_SWITCHER_API_URL || !credential())
+    throw new Error("Set HASNA_SWITCHER_API_URL and HASNA_SWITCHER_API_KEY; no local database fallback is available.");
+  return new SwitcherClient({ baseUrl: env.HASNA_SWITCHER_API_URL, apiKey: credential });
+}
+
+// src/mcp.ts
+var server = new McpServer({ name: "switcher", version: VERSION });
+var page = { limit: z2.number().int().min(1).max(1000).optional(), offset: z2.number().int().nonnegative().optional(), search: z2.string().optional() };
+function tool(name, description, schema, run) {
+  server.tool(name, description, schema, async (input) => {
+    try {
+      return { content: [{ type: "text", text: JSON.stringify(await run(input)) }] };
+    } catch {
+      return { isError: true, content: [{ type: "text", text: "Switcher API operation failed. Check configuration, input and API availability." }] };
+    }
+  });
+}
+tool("providers_list", "List provider profiles.", page, (p) => clientFromEnv().listProviders(p));
+tool("providers_get", "Get a provider.", { id: z2.string() }, (p) => clientFromEnv().getProvider(p.id));
+tool("providers_create", "Create a provider using credential environment references only.", providerInputSchema.innerType().shape, (p) => clientFromEnv().createProvider(p));
+tool("providers_update", "Replace a provider at its current version.", { provider: providerInputSchema, version: z2.number().int() }, (p) => clientFromEnv().updateProvider(p.provider, p.version));
+tool("providers_delete", "Delete an unreferenced provider.", { id: z2.string(), version: z2.number().int() }, (p) => clientFromEnv().deleteProvider(p.id, p.version));
+tool("models_list", "List catalog with capability information.", { id: z2.string(), ...page }, (p) => {
+  const { id, ...rest } = p;
+  return clientFromEnv().listModels(id, rest);
+});
+tool("models_refresh", "Discover provider models.", { id: z2.string() }, (p) => clientFromEnv().refreshModels(p.id));
+tool("profiles_list", "List harness launch profiles.", page, (p) => clientFromEnv().listProfiles(p));
+tool("profiles_get", "Get a harness profile.", { id: z2.string() }, (p) => clientFromEnv().getProfile(p.id));
+tool("profiles_create", "Create a harness launch profile.", profileInputSchema.shape, (p) => clientFromEnv().createProfile(p));
+tool("profiles_update", "Replace a harness profile at its version.", { profile: profileInputSchema, version: z2.number().int() }, (p) => clientFromEnv().updateProfile(p.profile, p.version));
+tool("profiles_delete", "Delete a profile without run history.", { id: z2.string(), version: z2.number().int() }, (p) => clientFromEnv().deleteProfile(p.id, p.version));
+tool("launch_plan", "Validate a local launch plan; does not execute a remote process.", { profileId: z2.string() }, (p) => clientFromEnv().launchPlan(p.profileId));
+tool("runs_list", "List launch metadata.", page, (p) => clientFromEnv().listRuns(p));
+tool("runs_get", "Get launch metadata.", { id: z2.string() }, (p) => clientFromEnv().getRun(p.id));
+if (process.argv.includes("--version"))
+  console.log(VERSION);
+else if (process.argv.includes("--help"))
+  console.log("switcher-mcp: authenticated Switcher API tools over MCP stdio. Requires HASNA_SWITCHER_API_URL and HASNA_SWITCHER_API_KEY.");
+else
+  await server.connect(new StdioServerTransport);

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};