@uru-intelligence/cli 0.1.0

package/dist/uru.mjs

@@ -0,0 +1,1605 @@
+#!/usr/bin/env node
+// @bun
+
+// src/cli.ts
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+
+// ../../packages/platform-operations/src/index.ts
+var ALL_SURFACES = [
+  "cli",
+  "mcp",
+  "docs"
+];
+var gemOperations = [
+  op("gem.init", "gems", "Create a Gem project at a visible library/<name>.gem path.", "gem_control_plane", "init", "write"),
+  op("gem.inspect", "gems", "Inspect Gem release readiness, bindings, secrets, and setup checks.", "gem_query", "inspect", "read"),
+  op("gem.fs_tree", "gems", "List files in a Gem project directory.", "gem_query", "fs_tree", "read"),
+  op("gem.fs_read", "gems", "Read a file from a Gem project directory.", "gem_query", "fs_read", "read"),
+  op("gem.fs_write", "gems", "Write a file inside a Gem project directory.", "gem_control_plane", "fs_write", "write"),
+  op("gem.fs_batch_write", "gems", "Write multiple Gem files atomically through the server source layer.", "gem_control_plane", "fs_batch_write", "write"),
+  op("gem.fs_patch", "gems", "Apply a patch to Gem source files.", "gem_control_plane", "fs_patch", "write"),
+  op("gem.fs_mkdir", "gems", "Create a directory inside a Gem project.", "gem_control_plane", "fs_mkdir", "write"),
+  op("gem.fs_rm", "gems", "Remove a file or directory from a Gem project.", "gem_control_plane", "fs_rm", "destructive"),
+  op("gem.fs_mv", "gems", "Move or rename a Gem project file.", "gem_control_plane", "fs_mv", "write"),
+  op("gem.fs_cp", "gems", "Copy a Gem project file.", "gem_control_plane", "fs_cp", "write"),
+  op("gem.fs_status", "gems", "Compare current Gem source against live, last build, or another version.", "gem_query", "fs_status", "read"),
+  op("gem.fs_diff", "gems", "Read a git-like diff for Gem source changes.", "gem_query", "fs_diff", "read"),
+  op("gem.validate", "gems", "Validate and build-check the current Gem source without publishing.", "gem_control_plane", "validate", "read"),
+  op("gem.build", "gems", "Create or reuse a ready server-side Gem build.", "gem_control_plane", "build", "write"),
+  op("gem.build_logs", "gems", "Read build diagnostics for a Gem build.", "gem_query", "build_logs", "read"),
+  op("gem.build_inspect", "gems", "Inspect a Gem runtime contract and release overview.", "gem_query", "build_inspect", "read"),
+  op("gem.upsert_binding", "gems", "Bind a declared Gem need to an approved platform resource.", "gem_control_plane", "upsert_binding", "write"),
+  op("gem.resolve_safe_bindings", "gems", "Resolve deterministic safe bindings for a ready Gem build.", "gem_control_plane", "resolve_safe_bindings", "write"),
+  op("gem.store_secret", "gems", "Store a user-supplied Gem secret value server-side.", "gem_control_plane", "store_secret", "write"),
+  op("gem.deploy", "gems", "Deploy a Gem using the server-side build/deploy/publish lifecycle.", "gem_control_plane", "deploy", "write"),
+  op("gem.status", "gems", "Read Gem deployment status, checks, runtime runs, and recent logs.", "gem_query", "deployment_status", "read"),
+  op("gem.logs", "gems", "Read server-side Gem runtime logs with filters.", "gem_query", "logs", "read"),
+  op("gem.browser_verify", "gems", "Run browser verification for a Gem deployment.", "gem_query", "browser_verify", "read"),
+  op("gem.security_scan", "gems", "Run a Gem security scan.", "gem_query", "security_scan", "read"),
+  op("gem.promote", "gems", "Promote a published Gem link to a deployment.", "gem_control_plane", "promote", "write"),
+  op("gem.rollback", "gems", "Repoint a published Gem link to a previous immutable deployment.", "gem_control_plane", "rollback", "destructive"),
+  op("gem.publish", "gems", "Publish or repoint a Gem link to a source version or deployment.", "gem_control_plane", "publish", "write"),
+  op("gem.unpublish", "gems", "Remove the published primary link for a Gem.", "gem_control_plane", "unpublish", "destructive"),
+  op("gem.links_list", "gems", "List published links for a Gem.", "gem_query", "links_list", "read"),
+  op("gem.links_create", "gems", "Create an additional published Gem link.", "gem_control_plane", "links_create", "write"),
+  op("gem.set_access", "gems", "Update access gates for a Gem link.", "gem_control_plane", "set_access", "write"),
+  op("gem.analytics", "gems", "Read Gem view analytics.", "gem_query", "get_gem_analytics", "read"),
+  op("gem.domains_set", "gems", "Attach or update a custom domain for a Gem.", "gem_control_plane", "domains_set", "write"),
+  op("gem.domains_list", "gems", "List custom domains for a Gem.", "gem_query", "domains_list", "read"),
+  op("gem.components_list", "gems", "List verified Gem component templates.", "GEM_COMPONENTS_LIST", undefined, "read"),
+  op("gem.components_get", "gems", "Fetch one verified Gem component definition.", "GEM_COMPONENTS_GET", undefined, "read")
+];
+var libraryOperations = [
+  op("library.ls", "library", "List visible Library folders and resources.", "library_query", "ls", "read"),
+  op("library.stat", "library", "Read metadata for a visible Library path.", "library_query", "stat", "read"),
+  op("library.search", "library", "Search visible Library resources server-side.", "library_query", "search", "read"),
+  op("library.mkdir", "library", "Create a Library folder.", "library_fs", "mkdir", "write"),
+  op("library.mv", "library", "Move or rename a Library item.", "library_fs", "mv", "write"),
+  op("library.move_workspace", "library", "Move a Library item to another workspace.", "library_fs", "move_workspace", "destructive"),
+  op("library.rm", "library", "Trash a Library item.", "library_fs", "rm", "destructive"),
+  op("library.restore", "library", "Restore a trashed Library item.", "library_fs", "restore", "write"),
+  op("library.empty_trash", "library", "Permanently empty Library trash.", "library_fs", "empty_trash", "destructive"),
+  op("library.upload_preflight", "library", "Preflight a Library upload.", "library_upload", "preflight", "read"),
+  op("library.upload_create_session", "library", "Create a direct Library upload session.", "library_upload", "create_session", "write"),
+  op("library.upload_complete_session", "library", "Complete a direct Library upload session.", "library_upload", "complete_session", "write")
+];
+var sharingOperations = [
+  op("sharing.share", "sharing", "Share a Library resource with a user, team, or workspace.", "library_collab", "share", "write"),
+  op("sharing.unshare", "sharing", "Remove a Library resource grant.", "library_collab", "unshare", "destructive"),
+  op("sharing.permissions_list", "sharing", "List permissions for a Library resource.", "library_collab", "list_permissions", "read"),
+  op("sharing.permissions_set", "sharing", "Set permissions for a Library resource.", "library_collab", "set_permissions", "write"),
+  op("sharing.settings_set", "sharing", "Set share settings for a Library resource.", "library_collab", "set_share_settings", "write"),
+  op("sharing.transfer_ownership", "sharing", "Transfer ownership for a Library resource.", "library_collab", "transfer_ownership", "destructive"),
+  op("sharing.versions_list", "sharing", "List Library resource versions.", "library_collab", "list_versions", "read"),
+  op("sharing.version_restore", "sharing", "Restore a Library resource version.", "library_collab", "restore_version", "destructive"),
+  op("sharing.comment", "sharing", "Comment on a Library resource.", "library_collab", "comment", "write"),
+  op("sharing.comment_resolve", "sharing", "Resolve a Library resource comment.", "library_collab", "resolve_comment", "write"),
+  op("sharing.label", "sharing", "Apply a Library label.", "library_collab", "label", "write"),
+  op("sharing.unlabel", "sharing", "Remove a Library label.", "library_collab", "unlabel", "write")
+];
+var datasetOperations = [
+  op("dataset.query", "datasets", "Query dataset rows with server-side filters, sort, search, and aggregates.", "dataset_query", undefined, "read"),
+  op("dataset.rows_upsert", "datasets", "Upsert dataset rows.", "dataset_rows", "upsert", "write"),
+  op("dataset.rows_delete", "datasets", "Soft-delete dataset rows.", "dataset_rows", "delete", "destructive"),
+  op("dataset.rows_restore", "datasets", "Restore soft-deleted dataset rows.", "dataset_rows", "restore", "write"),
+  op("dataset.get", "datasets", "Get dataset metadata and canonical schema.", "dataset_get", undefined, "read"),
+  op("dataset.manage_create", "datasets", "Create a typed dataset with canonical schema.", "dataset_manage", "create", "write"),
+  op("dataset.manage_update", "datasets", "Update dataset metadata or canonical schema.", "dataset_manage", "update", "write"),
+  op("dataset.sql", "datasets", "Execute scoped dataset SQL.", "dataset_sql", undefined, "write")
+];
+var workspaceOperations = [
+  op("workspace.list", "workspace", "List available workspaces.", "list_workspaces", undefined, "read"),
+  op("workspace.switch", "workspace", "Set current workspace for a session.", "set_current_workspace", undefined, "write"),
+  op("workspace.teams_list", "workspace", "List workspace teams.", "list_workspace_teams", undefined, "read"),
+  op("workspace.members_list", "workspace", "List workspace members for sharing.", "workspace_members_list", undefined, "read")
+];
+var automationOperations = [
+  op("automation.list", "automations", "List workspace automations.", "LIST_AUTOMATIONS", undefined, "read"),
+  op("automation.get", "automations", "Get one automation definition.", "GET_AUTOMATION", undefined, "read"),
+  op("automation.runs_list", "automations", "List automation runs.", "LIST_AUTOMATION_RUNS", undefined, "read"),
+  op("automation.run_debug", "automations", "Debug an automation run.", "DEBUG_AUTOMATION_RUN", undefined, "read"),
+  op("automation.run_logs", "automations", "Read automation run logs.", "GET_AUTOMATION_RUN_LOGS", undefined, "read"),
+  op("automation.run_timeline", "automations", "Read automation run timeline.", "GET_AUTOMATION_RUN_TIMELINE", undefined, "read"),
+  op("automation.triggers_discover", "automations", "Discover automation triggers.", "DISCOVER_TRIGGERS", undefined, "read"),
+  op("automation.connections_list", "automations", "List automation connections.", "LIST_CONNECTIONS", undefined, "read"),
+  op("automation.create", "automations", "Create an automation.", "CREATE_AUTOMATION", undefined, "write"),
+  op("automation.update", "automations", "Update automation metadata.", "UPDATE_AUTOMATION", undefined, "write"),
+  op("automation.delete", "automations", "Delete an automation.", "DELETE_AUTOMATION", undefined, "destructive"),
+  op("automation.graph_patch", "automations", "Patch an automation graph.", "PATCH_AUTOMATION_GRAPH", undefined, "write"),
+  op("automation.trigger_create", "automations", "Create an automation trigger.", "CREATE_AUTOMATION_TRIGGER", undefined, "write"),
+  op("automation.trigger_update", "automations", "Update an automation trigger.", "UPDATE_AUTOMATION_TRIGGER", undefined, "write"),
+  op("automation.trigger_delete", "automations", "Delete an automation trigger.", "DELETE_AUTOMATION_TRIGGER", undefined, "destructive")
+];
+var webAndFileOperations = [
+  op("web.search", "web", "Search the web.", "web_search", undefined, "read"),
+  op("web.fetch", "web", "Fetch a web page.", "web_fetch", undefined, "read"),
+  op("web.search_and_fetch", "web", "Search and fetch web pages.", "web_search_and_fetch", undefined, "read"),
+  op("file.download_content", "files", "Download file content for agent use.", "DOWNLOAD_FILE_CONTENT", undefined, "read"),
+  op("file.download_for_user", "files", "Prepare a file download for the user.", "DOWNLOAD_FILE_FOR_USER", undefined, "read")
+];
+var businessSqlOperations = [
+  op("business_sql.transcript", "business_sql", "Query transcript SQL.", "TRANSCRIPT_SQL", undefined, "read"),
+  op("business_sql.maguire", "business_sql", "Query Maguire SQL.", "MAGUIRE_SQL", undefined, "read"),
+  op("business_sql.tyler", "business_sql", "Query Tyler SQL.", "TYLER_SQL", undefined, "read"),
+  op("business_sql.cfo", "business_sql", "Query CFO SQL.", "CFO_SQL", undefined, "read"),
+  op("business_sql.cfo_newsletter", "business_sql", "Query CFO newsletter SQL.", "CFO_NEWSLETTER_SQL", undefined, "read"),
+  op("business_sql.clients", "business_sql", "Query clients SQL.", "CLIENTS_SQL", undefined, "read"),
+  op("business_sql.peregrine", "business_sql", "Query Peregrine SQL.", "PEREGRINE_SQL", undefined, "read"),
+  op("business_sql.maguire_write", "business_sql", "Run Maguire write SQL.", "MAGUIRE_WRITE_SQL", undefined, "destructive")
+];
+var registryUtilityOperations = [
+  op("tools.search", "tools", "Search platform tools by task.", "search_tools", undefined, "read"),
+  op("tools.list", "tools", "List platform tools.", "list_platform_tools", undefined, "read", ["cli", "docs"]),
+  op("tools.schema", "tools", "Read a platform tool schema.", "get_platform_tool_schema", undefined, "read", ["cli", "docs"]),
+  op("tools.run", "tools", "Run a platform tool by name.", "execute_platform_tool_by_name", undefined, "write", ["cli", "docs"])
+];
+var plannedOperations = [
+  op("secret.put", "secrets", "Store a secret value; planned first-class CLI/MCP wrapper over Gem/platform secret storage.", "gem_control_plane", "store_secret", "write"),
+  op("secret.list", "secrets", "List secret metadata without values; planned first-class wrapper.", "gem_query", "inspect", "read"),
+  op("env.pull", "env", "Materialize environment metadata locally; planned CLI wrapper.", "gem_query", "inspect", "read", ["docs"]),
+  op("token.create", "tokens", "Create scoped platform or Gem deploy tokens; planned backend capability.", "TOKEN_MANAGE", "create", "write", ["docs"]),
+  op("token.list", "tokens", "List scoped platform or Gem deploy tokens; planned backend capability.", "TOKEN_MANAGE", "list", "read", ["docs"]),
+  op("token.revoke", "tokens", "Revoke a scoped platform or Gem deploy token; planned backend capability.", "TOKEN_MANAGE", "revoke", "destructive", ["docs"])
+];
+var platformOperations = [
+  ...gemOperations,
+  ...libraryOperations,
+  ...sharingOperations,
+  ...datasetOperations,
+  ...workspaceOperations,
+  ...automationOperations,
+  ...webAndFileOperations,
+  ...businessSqlOperations,
+  ...registryUtilityOperations,
+  ...plannedOperations
+];
+function getPlatformOperation(id) {
+  return platformOperations.find((operation) => operation.id === id);
+}
+function platformOperationsForSurface(surface) {
+  return platformOperations.filter((operation) => operation.surfaces.includes(surface));
+}
+function op(id, family, summary, backendToolName, backendOp, safety, surfaces = ALL_SURFACES) {
+  return {
+    id,
+    family,
+    summary,
+    backendToolName,
+    ...backendOp ? { backendOp } : {},
+    safety,
+    surfaces
+  };
+}
+
+// src/types.ts
+var DEFAULT_API_URL = "https://api.uruintelligence.com";
+var CLI_VERSION = "0.1.0";
+var ExitCode = {
+  Ok: 0,
+  Failure: 1,
+  Cancelled: 2,
+  Conflict: 3,
+  AuthRequired: 4
+};
+
+class CliError extends Error {
+  exitCode;
+  constructor(message, options = {}) {
+    super(message, options.cause === undefined ? undefined : { cause: options.cause });
+    this.name = "CliError";
+    this.exitCode = options.code ?? ExitCode.Failure;
+  }
+}
+
+// src/args.ts
+var VALUE_FLAGS = new Set([
+  "--api-url",
+  "--token",
+  "--token-file",
+  "--workspace",
+  "--cwd",
+  "--output-format"
+]);
+var BOOLEAN_FLAGS = new Set([
+  "--json",
+  "--help",
+  "-h",
+  "--no-input",
+  "--yes",
+  "--version",
+  "--token-stdin"
+]);
+function parseArgs(argv) {
+  const command = [];
+  const flags = {
+    json: false,
+    help: false,
+    noInput: false,
+    yes: false
+  };
+  let parsingFlags = true;
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === undefined) {
+      continue;
+    }
+    if (parsingFlags && arg === "--") {
+      parsingFlags = false;
+      continue;
+    }
+    if (parsingFlags && arg.startsWith("--")) {
+      const [flagName, inlineValue] = splitFlag(arg);
+      if (BOOLEAN_FLAGS.has(flagName)) {
+        if (inlineValue !== undefined) {
+          throw new CliError(`${flagName} does not take a value`);
+        }
+        applyBooleanFlag(flags, flagName);
+        continue;
+      }
+      if (VALUE_FLAGS.has(flagName)) {
+        const value = inlineValue ?? argv[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+          throw new CliError(`${flagName} requires a value`);
+        }
+        if (inlineValue === undefined) {
+          index += 1;
+        }
+        applyValueFlag(flags, flagName, value);
+        continue;
+      }
+      if (command.length === 0) {
+        throw new CliError(`Unknown flag: ${flagName}`);
+      }
+      command.push(arg);
+      continue;
+    }
+    if (parsingFlags && BOOLEAN_FLAGS.has(arg)) {
+      applyBooleanFlag(flags, arg);
+      continue;
+    }
+    command.push(arg);
+  }
+  return { flags, command };
+}
+function requireCommandValue(value, message) {
+  if (value === undefined || value.trim() === "") {
+    throw new CliError(message, { code: ExitCode.Failure });
+  }
+  return value;
+}
+function splitFlag(arg) {
+  const equals = arg.indexOf("=");
+  if (equals === -1) {
+    return [arg, undefined];
+  }
+  return [arg.slice(0, equals), arg.slice(equals + 1)];
+}
+function applyBooleanFlag(flags, flag) {
+  if (flag === "--json") {
+    flags.json = true;
+    flags.outputFormat = "json";
+  } else if (flag === "--help" || flag === "-h") {
+    flags.help = true;
+  } else if (flag === "--version") {
+    flags.version = true;
+  } else if (flag === "--token-stdin") {
+    flags.tokenStdin = true;
+  } else if (flag === "--no-input") {
+    flags.noInput = true;
+  } else if (flag === "--yes") {
+    flags.yes = true;
+  }
+}
+function applyValueFlag(flags, flag, value) {
+  if (flag === "--api-url") {
+    flags.apiUrl = value;
+  } else if (flag === "--token") {
+    flags.token = value;
+  } else if (flag === "--token-file") {
+    flags.tokenFile = value;
+  } else if (flag === "--workspace") {
+    flags.workspace = value;
+  } else if (flag === "--cwd") {
+    flags.cwd = value;
+  } else if (flag === "--output-format") {
+    if (value !== "json" && value !== "stream-json" && value !== "text") {
+      throw new CliError("--output-format must be text, json, or stream-json");
+    }
+    flags.outputFormat = value;
+    flags.json = value === "json";
+  }
+}
+
+// src/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asOptionalString(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function parseJsonObject(input, label) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (error) {
+    throw new Error(`${label} must be valid JSON`, { cause: error });
+  }
+  if (!isJsonObject(parsed)) {
+    throw new Error(`${label} must be a JSON object`);
+  }
+  return parsed;
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return Number.isFinite(value) || typeof value !== "number";
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.values(value).every(isJsonValue);
+}
+function isJsonObject(value) {
+  return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+function pickString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim() !== "") {
+      return value;
+    }
+  }
+  return;
+}
+
+// src/client.ts
+class UruApiClient {
+  apiUrl;
+  token;
+  workspaceId;
+  fetchImpl;
+  constructor(options) {
+    this.apiUrl = normalizeApiUrl(options.apiUrl ?? DEFAULT_API_URL);
+    if (!options.token?.trim()) {
+      throw new CliError("Authentication required. Run `uru login --token <token>` or pass --token/URU_TOKEN.", { code: ExitCode.AuthRequired });
+    }
+    this.token = options.token;
+    if (options.workspaceId?.trim()) {
+      this.workspaceId = options.workspaceId;
+    }
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  async validateToken() {
+    const body = await this.request("/api/auth/api-key/validate", {
+      method: "POST"
+    });
+    if (!isRecord(body)) {
+      throw new CliError("Unexpected token validation response");
+    }
+    return normalizeWhoami(body);
+  }
+  async listTools() {
+    const body = await this.request("/api/platform/tools", { method: "GET" });
+    if (!Array.isArray(body)) {
+      throw new CliError("Unexpected tools list response");
+    }
+    return body.flatMap(normalizeTool);
+  }
+  async getToolSchema(name) {
+    return this.request(`/api/platform/tools/${encodeURIComponent(name)}/schema`, {
+      method: "GET"
+    });
+  }
+  async runTool(name, parameters) {
+    return this.request(`/api/platform/tools/${encodeURIComponent(name)}/execute`, {
+      method: "POST",
+      body: { parameters }
+    });
+  }
+  async api(path, options) {
+    return this.request(path, options);
+  }
+  async request(path, options) {
+    const init = {
+      method: options.method,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: "application/json",
+        ...this.workspaceId === undefined ? {} : { "X-Uru-Workspace-Id": this.workspaceId },
+        ...options.body === undefined ? {} : { "Content-Type": "application/json" }
+      },
+      ...options.body === undefined ? {} : { body: JSON.stringify(options.body) }
+    };
+    const response = await this.fetchImpl(`${this.apiUrl}${path}`, init);
+    const text = await response.text();
+    const payload = parseResponseBody(text);
+    if (!response.ok) {
+      throw apiError(response.status, payload);
+    }
+    return payload;
+  }
+}
+function normalizeApiUrl(value) {
+  const trimmed = value.trim();
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+}
+function parseResponseBody(text) {
+  if (text.trim() === "") {
+    return null;
+  }
+  const parsed = JSON.parse(text);
+  if (!isJsonValue(parsed)) {
+    throw new CliError("API returned non-JSON data");
+  }
+  return parsed;
+}
+function apiError(status, payload) {
+  const message = errorMessage(payload) ?? `Uru API request failed with HTTP ${status}`;
+  return new CliError(message, {
+    code: status === 401 || status === 403 ? ExitCode.AuthRequired : ExitCode.Failure
+  });
+}
+function errorMessage(payload) {
+  if (!isRecord(payload)) {
+    return;
+  }
+  return asOptionalString(payload["message"]) ?? asOptionalString(payload["detail"]) ?? asOptionalString(payload["error"]) ?? asOptionalString(payload["errorMessage"]);
+}
+function normalizeWhoami(body) {
+  const result = {
+    workspaces: Array.isArray(body["workspaces"]) ? body["workspaces"].flatMap(normalizeWorkspace) : [],
+    workspaceSelectionRequired: body["workspaceSelectionRequired"] === true
+  };
+  const userId = asOptionalString(body["userId"]);
+  if (userId !== undefined) {
+    result.userId = userId;
+  }
+  const email = asOptionalString(body["email"]);
+  if (email !== undefined) {
+    result.email = email;
+  }
+  const workspaceId = asOptionalString(body["workspaceId"]);
+  if (workspaceId !== undefined) {
+    result.workspaceId = workspaceId;
+  }
+  if (isJsonObject(body["workspace"])) {
+    result.workspace = body["workspace"];
+  }
+  const workspaceSelectionMessage = asOptionalString(body["workspaceSelectionMessage"]);
+  if (workspaceSelectionMessage !== undefined) {
+    result.workspaceSelectionMessage = workspaceSelectionMessage;
+  }
+  return result;
+}
+function normalizeWorkspace(value) {
+  if (!isRecord(value)) {
+    return [];
+  }
+  const nestedWorkspace = isRecord(value["workspaces"]) ? value["workspaces"] : undefined;
+  const source = nestedWorkspace ?? value;
+  const id = pickString(source, ["id", "workspaceId", "workspace_id"]);
+  if (id === undefined) {
+    return [];
+  }
+  const workspace = { id };
+  const name = pickString(source, ["name", "workspaceName", "workspace_name"]);
+  if (name !== undefined) {
+    workspace.name = name;
+  }
+  const slug = pickString(source, ["slug", "workspaceSlug", "workspace_slug"]);
+  if (slug !== undefined) {
+    workspace.slug = slug;
+  }
+  const role = pickString(value, ["role", "userRole", "user_role"]);
+  if (role !== undefined) {
+    workspace.role = role;
+  }
+  return [workspace];
+}
+function normalizeTool(value) {
+  if (!isJsonObject(value)) {
+    return [];
+  }
+  const name = asOptionalString(value["name"]);
+  if (name === undefined) {
+    return [];
+  }
+  const tool = { name, raw: value };
+  const description = asOptionalString(value["description"]);
+  if (description !== undefined) {
+    tool.description = description;
+  }
+  if (isJsonObject(value["inputSchema"])) {
+    tool.inputSchema = value["inputSchema"];
+  }
+  if (isJsonObject(value["outputSchema"])) {
+    tool.outputSchema = value["outputSchema"];
+  }
+  return [tool];
+}
+
+// src/config.ts
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function resolveConfigHome(env = process.env) {
+  const explicit = env["URU_CONFIG_HOME"]?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const xdg = env["XDG_CONFIG_HOME"]?.trim();
+  if (xdg) {
+    return join(xdg, "uru");
+  }
+  return join(env["HOME"]?.trim() || homedir(), ".config", "uru");
+}
+function configPath(env = process.env) {
+  return join(resolveConfigHome(env), "config.json");
+}
+function createConfigStore(path = configPath()) {
+  return {
+    path,
+    async read() {
+      try {
+        const raw = await readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        return sanitizeConfig(parsed);
+      } catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+          return {};
+        }
+        throw error;
+      }
+    },
+    async write(config) {
+      await mkdir(dirname(path), { recursive: true });
+      const body = `${JSON.stringify(sanitizeConfig(config), null, 2)}
+`;
+      await writeFile(path, body, {
+        mode: constants.S_IRUSR | constants.S_IWUSR
+      });
+    },
+    async clear() {
+      await rm(path, { force: true });
+    }
+  };
+}
+function sanitizeConfig(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const config = {};
+  for (const key of ["apiUrl", "token", "workspace"]) {
+    const item = value[key];
+    if (typeof item === "string" && item.trim() !== "") {
+      config[key] = item;
+    }
+  }
+  return config;
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/cli.ts
+import { dirname as dirname3 } from "node:path";
+
+// src/project.ts
+import { mkdir as mkdir2, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
+function projectDir(cwd) {
+  return join2(resolve(cwd), ".uru");
+}
+function projectPath(cwd) {
+  return join2(projectDir(cwd), "project.json");
+}
+async function readLinkedProject(cwd) {
+  try {
+    const parsed = JSON.parse(await readFile2(projectPath(cwd), "utf8"));
+    return sanitizeLinkedProject(parsed);
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeLinkedProject(cwd, project) {
+  const sanitized = sanitizeLinkedProject(project);
+  if (sanitized.workspaceId === undefined && sanitized.gemId === undefined && sanitized.libraryPath === undefined) {
+    throw new CliError("Nothing to link. Pass --workspace and --gem or --path.");
+  }
+  const path = projectPath(cwd);
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(sanitized, null, 2)}
+`, { mode: 384 });
+}
+async function unlinkProject(cwd) {
+  await rm2(projectPath(cwd), { force: true });
+}
+function sanitizeLinkedProject(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const project = {};
+  for (const [source, target] of [
+    ["workspaceId", "workspaceId"],
+    ["workspace_id", "workspaceId"],
+    ["gemId", "gemId"],
+    ["gem_id", "gemId"],
+    ["libraryPath", "libraryPath"],
+    ["library_path", "libraryPath"]
+  ]) {
+    const raw = value[source];
+    if (typeof raw === "string" && raw.trim() !== "") {
+      project[target] = raw.trim();
+    }
+  }
+  return project;
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// src/cli-helpers.ts
+function parseApiArgs(args) {
+  let method = "GET";
+  let path;
+  let body;
+  const fields = {};
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === undefined) {
+      continue;
+    }
+    if (arg === "-X" || arg === "--method") {
+      method = requireCommandValue(args[index + 1], `${arg} requires a method`).toUpperCase();
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-X") && arg.length > 2) {
+      method = arg.slice(2).toUpperCase();
+      continue;
+    }
+    if (arg === "--body-json" || arg === "--data-json") {
+      body = parseParamsJson(requireCommandValue(args[index + 1], `${arg} requires a JSON object`), arg);
+      index += 1;
+      continue;
+    }
+    if (arg === "-F" || arg === "--field") {
+      addApiField(fields, requireCommandValue(args[index + 1], `${arg} requires key=value`));
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("-F") && arg.length > 2) {
+      addApiField(fields, arg.slice(2));
+      continue;
+    }
+    if (path === undefined) {
+      path = normalizeApiPath(arg);
+      continue;
+    }
+    throw new CliError(`Unexpected api argument: ${arg}`);
+  }
+  if (Object.keys(fields).length > 0) {
+    body = { ...body ?? {}, ...fields };
+    if (method === "GET") {
+      method = "POST";
+    }
+  }
+  return {
+    path: requireCommandValue(path, "Usage: uru api <path> [-X POST] [-F k=v] [--body-json {...}]"),
+    method,
+    ...body === undefined ? {} : { body }
+  };
+}
+function normalizeApiPath(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return `/api/${trimmed.replace(/^api\//, "")}`;
+}
+function addApiField(target, raw) {
+  const equals = raw.indexOf("=");
+  if (equals <= 0) {
+    throw new CliError("-F/--field requires key=value");
+  }
+  target[raw.slice(0, equals)] = raw.slice(equals + 1);
+}
+function paramsJson(args) {
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--params-json" || arg === "--args-json") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new CliError(`${arg} requires a JSON object`);
+      }
+      return parseParamsJson(value, arg);
+    }
+    if (arg?.startsWith("--params-json=")) {
+      return parseParamsJson(arg.slice("--params-json=".length), "--params-json");
+    }
+    if (arg?.startsWith("--args-json=")) {
+      return parseParamsJson(arg.slice("--args-json=".length), "--args-json");
+    }
+  }
+  return {};
+}
+function parseParamsJson(value, label) {
+  try {
+    return parseJsonObject(value, label);
+  } catch (error) {
+    throw new CliError(error instanceof Error ? error.message : `Invalid ${label}`, {
+      cause: error
+    });
+  }
+}
+function parseLocalFlags(args) {
+  const values = {};
+  const booleans = new Set;
+  const positionals = [];
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === undefined) {
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      positionals.push(arg);
+      continue;
+    }
+    const equals = arg.indexOf("=");
+    if (equals > -1) {
+      values[arg.slice(0, equals)] = arg.slice(equals + 1);
+      continue;
+    }
+    const next = args[index + 1];
+    if (next !== undefined && !next.startsWith("--")) {
+      values[arg] = next;
+      index += 1;
+    } else {
+      booleans.add(arg);
+    }
+  }
+  return { values, booleans, positionals };
+}
+function integerFlag(flags, name, fallback) {
+  const raw = flags.values[name];
+  if (raw === undefined) {
+    return fallback;
+  }
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isFinite(value) || value < 0) {
+    throw new CliError(`${name} must be a non-negative integer`);
+  }
+  return value;
+}
+function copyStringFlag(flags, target, flagName, paramName) {
+  const value = flags.values[flagName];
+  if (value !== undefined) {
+    target[paramName] = value;
+  }
+}
+function isJsonRequested(argv) {
+  return argv.includes("--json") || argv.includes("--output-format=json");
+}
+function nonEmptyString(value) {
+  if (value === undefined) {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed === "" ? undefined : trimmed;
+}
+
+// src/output.ts
+function writeJson(io, value) {
+  io.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function writeStreamJson(io, event, value) {
+  io.stdout.write(`${JSON.stringify({ event, ...objectPayload(value) })}
+`);
+}
+function writeText(io, value) {
+  io.stdout.write(value.endsWith(`
+`) ? value : `${value}
+`);
+}
+function formatWhoami(result) {
+  const lines = [`User: ${result.email ?? result.userId ?? "unknown"}`];
+  if (result.workspaceId !== undefined) {
+    lines.push(`Workspace: ${result.workspaceId}`);
+  } else if (result.workspaceSelectionRequired) {
+    lines.push("Workspace: not selected");
+  }
+  if (result.workspaces.length > 0) {
+    lines.push(`Workspaces: ${result.workspaces.length}`);
+  }
+  return lines.join(`
+`);
+}
+function formatWorkspaces(workspaces) {
+  if (workspaces.length === 0) {
+    return "No workspaces found";
+  }
+  return workspaces.map((workspace) => {
+    const label = workspace.name ?? workspace.slug ?? workspace.id;
+    const suffix = workspace.role === undefined ? "" : ` (${workspace.role})`;
+    return `${workspace.id}	${label}${suffix}`;
+  }).join(`
+`);
+}
+function formatTools(tools) {
+  if (tools.length === 0) {
+    return "No tools found";
+  }
+  return tools.map((tool) => {
+    const description = tool.description === undefined ? "" : `	${tool.description}`;
+    return `${tool.name}${description}`;
+  }).join(`
+`);
+}
+function formatOperations(family) {
+  const operations = platformOperationsForSurface("cli").filter((operation) => family === undefined || operation.family === family);
+  if (operations.length === 0) {
+    return family === undefined ? "No CLI operations found" : `No CLI operations found for family ${family}`;
+  }
+  return operations.map((operation) => `${operation.id}	${operation.backendToolName}${operation.backendOp === undefined ? "" : ` op=${operation.backendOp}`}	${operation.summary}`).join(`
+`);
+}
+function helpText() {
+  return `Usage: uru [global flags] <command>
+
+CORE
+  uru login --token <token> [--api-url <url>]       Store token auth locally
+  uru logout                                       Remove local CLI auth config
+  uru whoami [--json]                              Show authenticated user context
+  uru switch [workspace-id]                        List or set current workspace
+  uru link --path <library/...gem> [--gem <id>]     Link cwd to a Gem (.uru/project.json)
+  uru unlink                                       Remove cwd Gem link
+
+GEMS
+  uru init <library/name.gem>                       Initialize a Gem project
+  uru deploy [library/name.gem] [--no-publish]      Server-side build/deploy/publish
+  uru publish [library/name.gem]                    Publish the current Gem target
+  uru status [library/name.gem]                     Deployment status/checks/log summary
+  uru logs [library/name.gem] [--limit 100]         Runtime logs
+  uru open [library/name.gem]                       Print first published URL
+  uru rollback <deployment-id> --link-id <id>       Repoint a link to a deployment
+  uru gems inspect|validate|build [library/name.gem]
+  uru gems read <library/name.gem> <file>
+  uru gems write <library/name.gem> <file> --file ./local.html
+
+LIBRARY / DATASETS / TOOLS
+  uru library ls [path]                             List Library items
+  uru library search <query>                        Search Library items
+  uru library mkdir <path>                          Create a Library folder
+  # Prompts, personas, contexts: use typed Library paths such as library/Prompts/Foo.prompt.md
+  uru datasets query <dataset-slug> [--limit 50]    Query dataset rows
+  uru tools ls|schema <name>|run <name>             Full platform-tool parity
+  uru operations ls [--family gems]                 Print generated operation registry
+  uru operations run <operation-id> --params-json    Run any registry-backed operation
+  uru workspace|sharing|automations|web <op>         Registry families for full-platform parity
+  uru mcp config|install                              Print/write MCP client config
+  uru api <path> [-X POST] [-F k=v]                    Raw authenticated API call
+  uru docs [query]                                      Search local operation docs
+
+FLAGS
+  --json                                           Print JSON to stdout
+  --output-format text|json|stream-json             Machine output mode
+  --api-url <url>                                   Override API URL
+  --token <token>                                   Override auth token for this invocation
+  --token-file <path>                                Read auth token from a local file
+  --token-stdin                                      Read auth token from stdin
+  --workspace <id>                                  Select workspace for scoped commands
+  --cwd <path>                                      Resolve .uru link from this directory
+  --no-input                                        Never prompt; fail if data is missing
+  --yes                                             Confirm destructive operations
+  -h, --help                                        Show help
+`;
+}
+function objectPayload(value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    return value;
+  }
+  return { value };
+}
+
+// src/cli.ts
+var GENERIC_FAMILY_COMMANDS = {
+  workspace: "workspace",
+  sharing: "sharing",
+  automations: "automations",
+  automation: "automations",
+  web: "web",
+  files: "files",
+  file: "files",
+  "business-sql": "business_sql",
+  business_sql: "business_sql",
+  secrets: "secrets",
+  secret: "secrets",
+  env: "env",
+  tokens: "tokens",
+  token: "tokens"
+};
+async function runCli(options) {
+  const io = options.io ?? { stdout: process.stdout, stderr: process.stderr };
+  try {
+    const parsed = parseArgs(options.argv);
+    if (parsed.flags.version) {
+      writeText(io, CLI_VERSION);
+      return ExitCode.Ok;
+    }
+    if (parsed.flags.help || parsed.command.length === 0) {
+      writeText(io, helpText());
+      return ExitCode.Ok;
+    }
+    const store = options.configStore ?? createConfigStore();
+    const config = await store.read();
+    const flagToken = await resolveFlagToken(parsed.flags, options.stdin);
+    const envToken = nonEmptyString(options.env?.["URU_TOKEN"]);
+    const envApiUrl = nonEmptyString(options.env?.["URU_API_BASE"]) ?? nonEmptyString(options.env?.["URU_API_URL"]);
+    const envWorkspace = nonEmptyString(options.env?.["URU_WORKSPACE_ID"]);
+    const apiUrl = parsed.flags.apiUrl ?? envApiUrl ?? config.apiUrl ?? DEFAULT_API_URL;
+    const token = flagToken ?? envToken ?? config.token;
+    const cwd = parsed.flags.cwd ?? options.env?.["PWD"] ?? process.cwd();
+    const linkedProject = await readLinkedProject(cwd);
+    const workspace = parsed.flags.workspace ?? envWorkspace ?? linkedProject.workspaceId ?? config.workspace;
+    const outputFormat = parsed.flags.outputFormat ?? (parsed.flags.json ? "json" : "text");
+    const ctx = {
+      io,
+      store,
+      config,
+      apiUrl,
+      ...token !== undefined ? { token } : {},
+      ...workspace !== undefined ? { workspace } : {},
+      cwd,
+      json: outputFormat === "json",
+      outputFormat,
+      noInput: parsed.flags.noInput,
+      yes: parsed.flags.yes,
+      ...options.fetch !== undefined ? { fetch: options.fetch } : {}
+    };
+    await dispatch(ctx, parsed.command, linkedProject);
+    return ExitCode.Ok;
+  } catch (error) {
+    const cliError = normalizeError(error);
+    if (isJsonRequested(options.argv)) {
+      io.stderr.write(`${JSON.stringify({ error: cliError.message, exitCode: cliError.exitCode })}
+`);
+    } else {
+      io.stderr.write(`Error: ${cliError.message}
+`);
+    }
+    return cliError.exitCode;
+  }
+}
+async function resolveFlagToken(flags, stdin) {
+  if (flags.token !== undefined) {
+    return flags.token;
+  }
+  if (flags.tokenFile !== undefined) {
+    const token = (await readFile3(flags.tokenFile, "utf8")).trim();
+    if (token === "") {
+      throw new CliError(`Token file is empty: ${flags.tokenFile}`, {
+        code: ExitCode.AuthRequired
+      });
+    }
+    return token;
+  }
+  if (flags.tokenStdin === true) {
+    const input = stdin ?? process.stdin;
+    if ("isTTY" in input && input.isTTY === true) {
+      throw new CliError("Refusing to read token from an interactive TTY. Pipe a token to --token-stdin or use --token-file.", {
+        code: ExitCode.AuthRequired
+      });
+    }
+    const token = (await readAllStdin(input)).trim();
+    if (token === "") {
+      throw new CliError("No token received on stdin.", {
+        code: ExitCode.AuthRequired
+      });
+    }
+    return token;
+  }
+  return;
+}
+async function readAllStdin(input) {
+  const chunks = [];
+  for await (const chunk of input) {
+    chunks.push(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+  }
+  return chunks.join("");
+}
+async function dispatch(ctx, command, linkedProject) {
+  const [head, sub, third] = command;
+  if (head === "login") {
+    await login(ctx);
+    return;
+  }
+  if (head === "logout") {
+    await ctx.store.clear();
+    emit(ctx, { ok: true }, "Logged out");
+    return;
+  }
+  if (head === "whoami") {
+    const result = await client(ctx).validateToken();
+    ctx.json ? writeJson(ctx.io, result) : writeText(ctx.io, formatWhoami(result));
+    return;
+  }
+  if (head === "switch") {
+    if (sub === undefined) {
+      const identity = await client(ctx).validateToken();
+      ctx.json ? writeJson(ctx.io, identity.workspaces) : writeText(ctx.io, formatWorkspaces(identity.workspaces));
+      return;
+    }
+    await switchWorkspace(ctx, requireCommandValue(sub, "Usage: uru switch <workspace-id>"));
+    return;
+  }
+  if (head === "link") {
+    await linkProject(ctx, command.slice(1));
+    return;
+  }
+  if (head === "unlink") {
+    await unlinkProject(ctx.cwd);
+    emit(ctx, { ok: true }, "Unlinked");
+    return;
+  }
+  if (head === "operations") {
+    await dispatchOperations(ctx, sub, command.slice(2));
+    return;
+  }
+  if (head === "docs" || head === "help") {
+    dispatchDocs(ctx, command.slice(1));
+    return;
+  }
+  if (head === "api") {
+    await dispatchApi(ctx, command.slice(1));
+    return;
+  }
+  if (head === "mcp") {
+    await dispatchMcp(ctx, sub, command.slice(2));
+    return;
+  }
+  if (head === "tools") {
+    await dispatchTools(ctx, sub, third, command);
+    return;
+  }
+  if (head === "init") {
+    await withWorkspace(ctx);
+    await gemInit(ctx, command.slice(1));
+    return;
+  }
+  if (head === "deploy") {
+    await withWorkspace(ctx);
+    await gemDeploy(ctx, command.slice(1), linkedProject);
+    return;
+  }
+  if (head === "publish") {
+    await withWorkspace(ctx);
+    await emitGemTool(ctx, "gem.publish", {
+      path: gemPathFromArgs(command.slice(1), linkedProject)
+    });
+    return;
+  }
+  if (head === "status") {
+    await withWorkspace(ctx);
+    await emitGemTool(ctx, "gem.status", {
+      path: gemPathFromArgs(command.slice(1), linkedProject)
+    });
+    return;
+  }
+  if (head === "logs") {
+    await withWorkspace(ctx);
+    await gemLogs(ctx, command.slice(1), linkedProject);
+    return;
+  }
+  if (head === "open") {
+    await withWorkspace(ctx);
+    await gemOpen(ctx, command.slice(1), linkedProject);
+    return;
+  }
+  if (head === "rollback") {
+    await withWorkspace(ctx);
+    await gemRollback(ctx, command.slice(1), linkedProject);
+    return;
+  }
+  if (head === "gems") {
+    await withWorkspace(ctx);
+    await dispatchGems(ctx, sub, command.slice(2), linkedProject);
+    return;
+  }
+  if (head === "library") {
+    await withWorkspace(ctx);
+    await dispatchLibrary(ctx, sub, command.slice(2));
+    return;
+  }
+  if (head === "datasets") {
+    await withWorkspace(ctx);
+    await dispatchDatasets(ctx, sub, command.slice(2));
+    return;
+  }
+  const family = head === undefined ? undefined : GENERIC_FAMILY_COMMANDS[head];
+  if (family !== undefined) {
+    await withWorkspace(ctx);
+    await dispatchRegistryFamily(ctx, family, sub, command.slice(2));
+    return;
+  }
+  throw new CliError(`Unknown command: ${command.join(" ")}`);
+}
+function dispatchDocs(ctx, args) {
+  const query = args.join(" ").trim();
+  if (query === "") {
+    writeText(ctx.io, helpText());
+    return;
+  }
+  const matches = formatOperations().split(`
+`).filter((line) => line.toLowerCase().includes(query.toLowerCase())).join(`
+`);
+  writeText(ctx.io, matches || `No operation docs matched ${query}`);
+}
+async function dispatchApi(ctx, args) {
+  await withWorkspace(ctx);
+  const parsed = parseApiArgs(args);
+  const result = await client(ctx).api(parsed.path, {
+    method: parsed.method,
+    ...parsed.body === undefined ? {} : { body: parsed.body }
+  });
+  if (ctx.outputFormat === "stream-json") {
+    writeStreamJson(ctx.io, "result", result);
+  } else {
+    writeJson(ctx.io, result);
+  }
+}
+async function dispatchMcp(ctx, sub, args) {
+  if (sub !== "config" && sub !== "install") {
+    throw new CliError("Usage: uru mcp config|install [--api-key <key>] [--path <path>]");
+  }
+  const flags = parseLocalFlags(args);
+  const config = mcpServerConfig({
+    apiKey: flags.values["--api-key"] ?? ctx.token,
+    serverName: flags.values["--server-name"] ?? "uru",
+    packageName: flags.values["--package"] ?? "uru-mcp@latest"
+  });
+  if (sub === "config") {
+    writeJson(ctx.io, config);
+    return;
+  }
+  const path = requireCommandValue(flags.values["--path"], "Usage: uru mcp install --path <mcp-config.json> [--api-key <key>]");
+  await mkdir3(dirname3(path), { recursive: true });
+  await writeFile3(path, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  emit(ctx, { ok: true, path }, `Wrote MCP config to ${path}`);
+}
+function mcpServerConfig(args) {
+  const apiKey = requireCommandValue(args.apiKey, "MCP config requires --api-key, --token, URU_TOKEN, or a logged-in CLI token.");
+  return {
+    mcpServers: {
+      [args.serverName]: {
+        command: "npx",
+        args: [args.packageName],
+        env: { URU_API_KEY: apiKey }
+      }
+    }
+  };
+}
+async function dispatchOperations(ctx, sub, args) {
+  if (sub === "ls" || sub === "list") {
+    const flags = parseLocalFlags(args);
+    const family = flags.values["--family"];
+    writeText(ctx.io, formatOperations(family));
+    return;
+  }
+  if (sub === "run") {
+    await withWorkspace(ctx);
+    const operationId = requireCommandValue(args[0], "Usage: uru operations run <operation-id> --params-json '{...}'");
+    await emitTool(ctx, operationId, paramsJson(args.slice(1)));
+    return;
+  }
+  throw new CliError("Usage: uru operations ls [--family <family>] | run <operation-id> --params-json {...}");
+}
+async function dispatchRegistryFamily(ctx, family, sub, args) {
+  const verb = requireCommandValue(sub, `Usage: uru ${family.replace("_", "-")} <operation> --params-json '{...}'`).replace(/-/g, "_");
+  const operation = platformOperationsForSurface("cli").find((candidate) => candidate.family === family && candidate.id === `${familyPrefix(family)}.${verb}`);
+  if (operation === undefined) {
+    throw new CliError(`Unknown ${family} operation: ${verb}. Run \`uru operations ls --family ${family}\`.`);
+  }
+  await emitTool(ctx, operation.id, paramsJson(args));
+}
+function familyPrefix(family) {
+  if (family === "automations") {
+    return "automation";
+  }
+  if (family === "datasets") {
+    return "dataset";
+  }
+  if (family === "files") {
+    return "file";
+  }
+  if (family === "secrets") {
+    return "secret";
+  }
+  if (family === "tokens") {
+    return "token";
+  }
+  return family;
+}
+async function dispatchTools(ctx, sub, third, command) {
+  if (sub === "ls") {
+    await withWorkspace(ctx);
+    const tools = await client(ctx).listTools();
+    ctx.json ? writeJson(ctx.io, tools.map((tool) => tool.raw)) : writeText(ctx.io, formatTools(tools));
+    return;
+  }
+  if (sub === "schema") {
+    await withWorkspace(ctx);
+    const name = requireCommandValue(third, "Usage: uru tools schema <name>");
+    writeJson(ctx.io, await client(ctx).getToolSchema(name));
+    return;
+  }
+  if (sub === "run") {
+    await withWorkspace(ctx);
+    const name = requireCommandValue(third, "Usage: uru tools run <name> --params-json '{...}'");
+    const params = paramsJson(command.slice(3));
+    writeJson(ctx.io, await client(ctx).runTool(name, params));
+    return;
+  }
+  throw new CliError("Usage: uru tools ls|schema|run");
+}
+async function dispatchGems(ctx, sub, args, linkedProject) {
+  const gemPath = () => gemPathFromArgs(args, linkedProject);
+  if (sub === "inspect") {
+    await emitGemTool(ctx, "gem.inspect", { path: gemPath() });
+    return;
+  }
+  if (sub === "validate") {
+    await emitGemTool(ctx, "gem.validate", { path: gemPath() });
+    return;
+  }
+  if (sub === "build") {
+    const flags = parseLocalFlags(args);
+    await emitGemTool(ctx, "gem.build", {
+      path: gemPathFromArgs(flags.positionals, linkedProject),
+      ...flags.booleans.has("--force") ? { force: true } : {}
+    });
+    return;
+  }
+  if (sub === "read") {
+    const [path, file] = args;
+    await emitGemTool(ctx, "gem.fs_read", {
+      path: gemFilePath(requireCommandValue(path, "Usage: uru gems read <gem-path> <file>"), requireCommandValue(file, "Usage: uru gems read <gem-path> <file>"))
+    });
+    return;
+  }
+  if (sub === "write") {
+    await gemWrite(ctx, args);
+    return;
+  }
+  throw new CliError("Usage: uru gems inspect|validate|build|read|write");
+}
+async function dispatchLibrary(ctx, sub, args) {
+  if (sub === "ls") {
+    await emitTool(ctx, "library.ls", {
+      path: args[0] ?? "library",
+      recursive: false
+    });
+    return;
+  }
+  if (sub === "search") {
+    await emitTool(ctx, "library.search", {
+      query: requireCommandValue(args[0], "Usage: uru library search <query>")
+    });
+    return;
+  }
+  if (sub === "mkdir") {
+    await emitTool(ctx, "library.mkdir", {
+      path: requireCommandValue(args[0], "Usage: uru library mkdir <path>"),
+      recursive: true
+    });
+    return;
+  }
+  throw new CliError("Usage: uru library ls|search|mkdir");
+}
+async function dispatchDatasets(ctx, sub, args) {
+  if (sub !== "query") {
+    await dispatchRegistryFamily(ctx, "datasets", sub, args);
+    return;
+  }
+  const flags = parseLocalFlags(args);
+  const datasetId = requireCommandValue(flags.positionals[0], "Usage: uru datasets query <dataset-slug> [--limit 50]");
+  await emitTool(ctx, "dataset.query", {
+    dataset_id: datasetId,
+    datasetId,
+    limit: integerFlag(flags, "--limit", 50),
+    offset: integerFlag(flags, "--offset", 0)
+  });
+}
+async function login(ctx) {
+  if (ctx.token === undefined || ctx.token.trim() === "") {
+    throw new CliError("Token required. Run `uru login --token <token>`.", {
+      code: ExitCode.AuthRequired
+    });
+  }
+  const result = await client(ctx).validateToken();
+  const selectedWorkspace = selectWorkspace(result, ctx.workspace);
+  const nextConfig = {
+    ...ctx.config,
+    apiUrl: ctx.apiUrl,
+    token: ctx.token,
+    ...selectedWorkspace !== undefined ? { workspace: selectedWorkspace } : {}
+  };
+  await ctx.store.write(nextConfig);
+  if (ctx.json) {
+    writeJson(ctx.io, {
+      ok: true,
+      apiUrl: ctx.apiUrl,
+      userId: result.userId,
+      email: result.email,
+      workspaceId: selectedWorkspace,
+      workspaceSelectionRequired: result.workspaceSelectionRequired
+    });
+  } else {
+    writeText(ctx.io, "Logged in");
+  }
+}
+async function linkProject(ctx, args) {
+  const flags = parseLocalFlags(args);
+  const project = {};
+  const workspace = flags.values["--workspace"] ?? ctx.workspace;
+  const gemId = flags.values["--gem"];
+  const libraryPath = flags.values["--path"] ?? flags.positionals[0];
+  if (workspace !== undefined) {
+    project.workspaceId = workspace;
+  }
+  if (gemId !== undefined) {
+    project.gemId = gemId;
+  }
+  if (libraryPath !== undefined) {
+    project.libraryPath = libraryPath;
+  }
+  await writeLinkedProject(ctx.cwd, project);
+  emit(ctx, { ok: true, ...project }, `Linked ${project.libraryPath ?? project.gemId ?? "Gem"}`);
+}
+async function switchWorkspace(ctx, workspaceId) {
+  const identity = await client(ctx).validateToken();
+  assertWorkspaceAvailable(identity, workspaceId);
+  const nextConfig = {
+    ...ctx.config,
+    apiUrl: ctx.apiUrl,
+    workspace: workspaceId
+  };
+  if (ctx.token !== undefined) {
+    nextConfig.token = ctx.token;
+  }
+  await ctx.store.write(nextConfig);
+  emit(ctx, { ok: true, workspaceId }, `Switched to workspace ${workspaceId}`);
+}
+async function withWorkspace(ctx) {
+  if (ctx.workspace !== undefined && ctx.workspace.trim() !== "") {
+    return;
+  }
+  const identity = await client(ctx).validateToken();
+  if (identity.workspaceSelectionRequired) {
+    throw new CliError(`${identity.workspaceSelectionMessage ?? "Workspace selection required"} Run \`uru switch <workspace-id>\`, \`uru link --workspace <workspace-id>\`, or pass --workspace.`, { code: ExitCode.AuthRequired });
+  }
+}
+async function gemInit(ctx, args) {
+  const flags = parseLocalFlags(args);
+  const path = requireCommandValue(flags.positionals[0], "Usage: uru init <library/name.gem> [--entrypoint main.html] [--file ./main.html]");
+  const params = { path };
+  copyStringFlag(flags, params, "--name", "name");
+  copyStringFlag(flags, params, "--description", "description");
+  copyStringFlag(flags, params, "--entrypoint", "entrypoint");
+  copyStringFlag(flags, params, "--runtime", "runtime");
+  copyStringFlag(flags, params, "--visibility", "visibility");
+  if (flags.values["--content"] !== undefined) {
+    params["content"] = flags.values["--content"];
+  }
+  if (flags.values["--file"] !== undefined) {
+    params["content"] = await readFile3(flags.values["--file"], "utf8");
+  }
+  await emitGemTool(ctx, "gem.init", params);
+}
+async function gemDeploy(ctx, args, linkedProject) {
+  const flags = parseLocalFlags(args);
+  const params = {
+    path: gemPathFromArgs(flags.positionals, linkedProject),
+    publish: !flags.booleans.has("--no-publish")
+  };
+  copyStringFlag(flags, params, "--build-id", "build_id");
+  copyStringFlag(flags, params, "--runtime-provider", "runtime_provider");
+  if (flags.booleans.has("--force-build")) {
+    params["force_build"] = true;
+  }
+  await emitGemTool(ctx, "gem.deploy", params, {
+    textExtractor: extractDeploymentUrl
+  });
+}
+async function gemLogs(ctx, args, linkedProject) {
+  const flags = parseLocalFlags(args);
+  const params = {
+    path: gemPathFromArgs(flags.positionals, linkedProject),
+    limit: integerFlag(flags, "--limit", 100)
+  };
+  copyStringFlag(flags, params, "--level", "level");
+  copyStringFlag(flags, params, "--deployment-id", "deployment_id");
+  copyStringFlag(flags, params, "--request-id", "request_id");
+  await emitGemTool(ctx, "gem.logs", params);
+}
+async function gemOpen(ctx, args, linkedProject) {
+  const result = await executeOperation(ctx, "gem.links_list", {
+    path: gemPathFromArgs(args, linkedProject)
+  });
+  const url = firstUrl(unwrapToolResult(result));
+  if (url === undefined) {
+    throw new CliError("No published URL found for this Gem. Run `uru deploy` first.");
+  }
+  ctx.json ? writeJson(ctx.io, { url }) : writeText(ctx.io, url);
+}
+async function gemRollback(ctx, args, linkedProject) {
+  const flags = parseLocalFlags(args);
+  if (!ctx.yes && !flags.booleans.has("--yes")) {
+    throw new CliError("Rollback requires --yes to confirm the link pointer change.");
+  }
+  await emitGemTool(ctx, "gem.rollback", {
+    path: gemPathFromArgs(flags.positionals.slice(1), linkedProject),
+    app_deployment_id: requireCommandValue(flags.positionals[0], "Usage: uru rollback <deployment-id> --link-id <link-id> --yes"),
+    link_id: requireCommandValue(flags.values["--link-id"], "Usage: uru rollback <deployment-id> --link-id <link-id> --yes")
+  });
+}
+async function gemWrite(ctx, args) {
+  const flags = parseLocalFlags(args);
+  const gemPath = requireCommandValue(flags.positionals[0], "Usage: uru gems write <gem-path> <file> --content <text>|--file <local-file>");
+  const filePath = requireCommandValue(flags.positionals[1], "Usage: uru gems write <gem-path> <file> --content <text>|--file <local-file>");
+  const content = flags.values["--content"] ?? (flags.values["--file"] === undefined ? undefined : await readFile3(flags.values["--file"], "utf8"));
+  if (content === undefined) {
+    throw new CliError("Gem write requires --content or --file.");
+  }
+  await emitGemTool(ctx, "gem.fs_write", {
+    path: gemFilePath(gemPath, filePath),
+    content,
+    create: !flags.booleans.has("--no-create")
+  });
+}
+async function emitGemTool(ctx, operationId, params, options = {}) {
+  await emitTool(ctx, operationId, params, options);
+}
+async function emitTool(ctx, operationId, params, options = {}) {
+  const result = await executeOperation(ctx, operationId, params);
+  const unwrapped = unwrapToolResult(result);
+  if (ctx.outputFormat === "stream-json") {
+    writeStreamJson(ctx.io, "result", unwrapped);
+  } else if (ctx.json) {
+    writeJson(ctx.io, unwrapped);
+  } else {
+    writeText(ctx.io, options.textExtractor?.(unwrapped) ?? JSON.stringify(unwrapped, null, 2));
+  }
+}
+async function executeOperation(ctx, operationId, params) {
+  const operation = getPlatformOperation(operationId);
+  if (operation === undefined) {
+    throw new CliError(`Unknown operation registry id: ${operationId}`);
+  }
+  const toolParams = { ...params };
+  if (operation.backendOp !== undefined) {
+    toolParams["op"] = operation.backendOp;
+  }
+  return client(ctx).runTool(operation.backendToolName, toolParams);
+}
+function client(ctx) {
+  return new UruApiClient({
+    apiUrl: ctx.apiUrl,
+    ...ctx.token !== undefined ? { token: ctx.token } : {},
+    ...ctx.workspace !== undefined ? { workspaceId: ctx.workspace } : {},
+    ...ctx.fetch !== undefined ? { fetch: ctx.fetch } : {}
+  });
+}
+function selectWorkspace(identity, requestedWorkspaceId) {
+  if (requestedWorkspaceId === undefined || requestedWorkspaceId.trim() === "") {
+    return identity.workspaceId;
+  }
+  assertWorkspaceAvailable(identity, requestedWorkspaceId);
+  return requestedWorkspaceId;
+}
+function assertWorkspaceAvailable(identity, workspaceId) {
+  if (identity.workspaceId === workspaceId || identity.workspaces.some((workspace) => workspace.id === workspaceId)) {
+    return;
+  }
+  throw new CliError(`Workspace ${workspaceId} is not available for the current token. Run \`uru switch\` to list available workspaces.`);
+}
+function gemPathFromArgs(args, linkedProject) {
+  const flags = parseLocalFlags(args);
+  return flags.values["--path"] ?? flags.positionals.find((value) => value.startsWith("library/")) ?? linkedProject.libraryPath ?? linkedProject.gemId ?? (() => {
+    throw new CliError("Gem path required. Pass library/<name>.gem or run `uru link --path library/<name>.gem`.");
+  })();
+}
+function gemFilePath(gemPath, filePath) {
+  const normalizedGemPath = trimTrailingSlashes(gemPath);
+  const normalizedFilePath = trimLeadingSlashes(filePath);
+  return `${normalizedGemPath}/${normalizedFilePath}`;
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+}
+function trimLeadingSlashes(value) {
+  let start = 0;
+  while (start < value.length && value.charCodeAt(start) === 47) {
+    start += 1;
+  }
+  return value.slice(start);
+}
+function emit(ctx, value, text) {
+  if (ctx.outputFormat === "stream-json") {
+    writeStreamJson(ctx.io, "result", value);
+  } else if (ctx.json) {
+    writeJson(ctx.io, value);
+  } else {
+    writeText(ctx.io, text);
+  }
+}
+function unwrapToolResult(value) {
+  if (isJsonObject2(value) && isJsonObject2(value["result"])) {
+    return value["result"];
+  }
+  return value;
+}
+function extractDeploymentUrl(value) {
+  return firstUrl(value);
+}
+function firstUrl(value) {
+  if (typeof value === "string" && /^https?:\/\//.test(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = firstUrl(item);
+      if (found !== undefined) {
+        return found;
+      }
+    }
+    return;
+  }
+  if (!isJsonObject2(value)) {
+    return;
+  }
+  for (const key of [
+    "published_url",
+    "publishedUrl",
+    "preview_url",
+    "previewUrl",
+    "url",
+    "href"
+  ]) {
+    const candidate = value[key];
+    if (typeof candidate === "string" && /^https?:\/\//.test(candidate)) {
+      return candidate;
+    }
+  }
+  for (const candidate of Object.values(value)) {
+    const found = firstUrl(candidate);
+    if (found !== undefined) {
+      return found;
+    }
+  }
+  return;
+}
+function isJsonObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeError(error) {
+  if (error instanceof CliError) {
+    return error;
+  }
+  return new CliError(error instanceof Error ? error.message : "Unknown error");
+}
+
+// src/index.ts
+var exitCode = await runCli({ argv: process.argv.slice(2), env: process.env });
+process.exitCode = exitCode;