@meistrari/tela-cli 0.7.23 → 0.7.25

package/README.md

@@ -19,6 +19,14 @@ tela context list --json
 tela context show <context-id> --json
 tela context use <context-id>
 tela env list --json
+tela update --json
+tela api <slug> <METHOD> <PATH> [args...] --env <slug> --body <json> --pretty
+tela docs endpoints <slug> --pretty
+tela docs reference <slug> [METHOD PATH|file-path] --pretty
+tela docs guide <slug> [path]
+tela env list <ingredient-slug> --pretty
+tela env set <ingredient-slug> <environment>
+tela whoami --pretty
 tela doctor auth --json
 tela agent sync [repo] --current --all --dry-run --json --verbose
 tela agent run --input <name=path>... --plain --json --verbose
@@ -31,6 +39,12 @@ may refresh a user-session credential in Keychain before returning metadata or
 printing a raw token. Creating, removing, editing, and repairing contexts are
 Dock-first workflows.
 
+The legacy `telactl` Pantry/service workflows are ported into this binary as
+top-level `update`, `api`, `docs`, `whoami`, and `token` commands. Ingredient
+cache and per-ingredient environment defaults live under `TELA_HOME` next to
+the Dock config, while credential material still comes from the selected Tela
+context through `@meistrari/tela-local-config`.
+
 ## Development
 
 From the repository root:

package/dist/commands/ingredients.d.ts

@@ -0,0 +1,38 @@
+import type { CliIo, GlobalOptions } from '../output';
+export type CachedEnvironment = {
+    slug: string;
+    url: string;
+};
+export type CachedIngredient = {
+    slug: string;
+    name: string;
+    description: string;
+    type: 'api' | 'library' | 'skill';
+    status: string;
+    environments: CachedEnvironment[];
+};
+type ParsedArg = {
+    kind: 'query';
+    key: string;
+    value: string;
+} | {
+    kind: 'header';
+    key: string;
+    value: string;
+} | {
+    kind: 'field';
+    key: string;
+    value: string;
+} | {
+    kind: 'rawField';
+    key: string;
+    value: string;
+};
+export declare function runTelactlCommand(command: string, args: string[], options: GlobalOptions, io: CliIo): Promise<number>;
+export declare function runIngredientEnvCommand(args: string[], options: GlobalOptions, io: CliIo): Promise<number | null>;
+export declare function fetchIngredientCatalog(headers: Record<string, string>, fetchImpl?: typeof fetch): Promise<CachedIngredient[]>;
+export declare function joinUrl(base: string, routePath: string): string;
+export declare function parseHttpieArg(arg: string): ParsedArg | null;
+export declare function extractGitHubFilePath(url: string): string | null;
+export declare function resolveGuidePath(rootFilePath: string, providedPath?: string): string;
+export {};

package/dist/index.js

@@ -133,14 +133,14 @@ var require_auth = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.shouldRefreshUserSession = shouldRefreshUserSession;
-    exports2.refreshUserSessionCredential = refreshUserSessionCredential2;
+    exports2.refreshUserSessionCredential = refreshUserSessionCredential3;
     exports2.createStoredUserSession = createStoredUserSession;
     exports2.getJwtExpiresAt = getJwtExpiresAt;
     var credentials_1 = require_credentials();
     function shouldRefreshUserSession(credential, now = refreshSkewDate()) {
       return credential.kind === "user-session" && Boolean(credential.refreshToken) && (0, credentials_1.isExpired)(credential, now);
     }
-    async function refreshUserSessionCredential2(environment, credentialRef, credential, credentials, options = {}) {
+    async function refreshUserSessionCredential3(environment, credentialRef, credential, credentials, options = {}) {
       if (!shouldRefreshUserSession(credential, options.now ?? refreshSkewDate())) {
         return credential;
       }
@@ -315,7 +315,7 @@ var require_paths = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.expandHome = expandHome;
-    exports2.getTelaLocalPaths = getTelaLocalPaths;
+    exports2.getTelaLocalPaths = getTelaLocalPaths2;
     exports2.configBackupPath = configBackupPath;
     var node_os_1 = require("node:os");
     var node_path_1 = require("node:path");
@@ -326,7 +326,7 @@ var require_paths = __commonJS({
         return (0, node_path_1.join)((0, node_os_1.homedir)(), path.slice(2));
       return path;
     }
-    function getTelaLocalPaths(rootDir = process.env.TELA_HOME ?? "~/.tela") {
+    function getTelaLocalPaths2(rootDir = process.env.TELA_HOME ?? "~/.tela") {
       const root = (0, node_path_1.resolve)(expandHome(rootDir));
       return {
         rootDir: root,
@@ -346,7 +346,7 @@ var require_config = __commonJS({
   "../../packages/local-config/dist/config.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.loadConfig = loadConfig5;
+    exports2.loadConfig = loadConfig6;
     exports2.saveConfig = saveConfig;
     exports2.updateConfig = updateConfig2;
     exports2.upsertEnvironment = upsertEnvironment;
@@ -367,7 +367,7 @@ var require_config = __commonJS({
       "Authorization",
       "x-data-token"
     ]);
-    async function loadConfig5(configFile = (0, paths_1.getTelaLocalPaths)().configFile) {
+    async function loadConfig6(configFile = (0, paths_1.getTelaLocalPaths)().configFile) {
       let raw;
       try {
         raw = await (0, promises_1.readFile)(configFile, "utf8");
@@ -388,7 +388,7 @@ var require_config = __commonJS({
       await (0, promises_1.rename)(tempFile, configFile);
     }
     async function updateConfig2(mutator, configFile = (0, paths_1.getTelaLocalPaths)().configFile) {
-      const current = await loadConfig5(configFile);
+      const current = await loadConfig6(configFile);
       const next = mutator(current) ?? current;
       await saveConfig(next, configFile);
       return next;
@@ -558,8 +558,8 @@ var require_context = __commonJS({
   "../../packages/local-config/dist/context.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolveContext = resolveContext2;
-    function resolveContext2(config, input = {}) {
+    exports2.resolveContext = resolveContext3;
+    function resolveContext3(config, input = {}) {
       const env = input.env ?? process.env;
       const contextId = input.contextId ?? env.TELA_CONTEXT ?? resolveFromEnvironmentAndWorkspace(config, input.environmentId, input.workspace) ?? config.activeContextId;
       if (!contextId) {
@@ -1518,7 +1518,7 @@ var require_agent_api = __commonJS({
     var tela_local_config_1 = require_dist();
     var auth_1 = require_auth2();
     var DEFAULT_TIMEOUT_MS = 1e4;
-    function joinUrl(baseUrl, path) {
+    function joinUrl2(baseUrl, path) {
       return new URL(path, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).toString();
     }
     function parseJsonBody(responseText) {
@@ -1589,7 +1589,7 @@ var require_agent_api = __commonJS({
     exports2.AgentApiError = AgentApiError;
     async function listOrganizations(config, fetchFn = fetch) {
       const headers = await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
-      const response = await fetchFn(joinUrl(config.agentApiUrl, "/v3/organizations"), {
+      const response = await fetchFn(joinUrl2(config.agentApiUrl, "/v3/organizations"), {
         method: "GET",
         headers,
         signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
@@ -1606,7 +1606,7 @@ var require_agent_api = __commonJS({
     }
     async function provisionForgejoUser(input, config, fetchFn = fetch) {
       const headers = await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
-      const response = await fetchFn(joinUrl(config.agentApiUrl, "/v3/forgejo/users"), {
+      const response = await fetchFn(joinUrl2(config.agentApiUrl, "/v3/forgejo/users"), {
         method: "POST",
         headers: {
           ...headers,
@@ -1630,7 +1630,7 @@ var require_agent_api = __commonJS({
     }
     async function fetchRepositoryLookup(repository, config, fetchFn = fetch) {
       const headers = await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
-      const response = await fetchFn(joinUrl(config.agentApiUrl, `/v3/agents/repositories/${encodeURIComponent(repository)}`), {
+      const response = await fetchFn(joinUrl2(config.agentApiUrl, `/v3/agents/repositories/${encodeURIComponent(repository)}`), {
         method: "GET",
         headers,
         signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
@@ -1652,7 +1652,7 @@ var require_agent_api = __commonJS({
     }
     async function fetchCommitFeedback(organizationName, repository, commitHash, config, fetchFn = fetch) {
       const headers = await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
-      const response = await fetchFn(joinUrl(config.agentApiUrl, `/v3/agents/${encodeURIComponent(organizationName)}/${encodeURIComponent(repository)}/feedback?commitHash=${encodeURIComponent(commitHash)}`), {
+      const response = await fetchFn(joinUrl2(config.agentApiUrl, `/v3/agents/${encodeURIComponent(organizationName)}/${encodeURIComponent(repository)}/feedback?commitHash=${encodeURIComponent(commitHash)}`), {
         method: "GET",
         headers,
         signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
@@ -1674,7 +1674,7 @@ var require_agent_api = __commonJS({
       if (!config.credential) {
         throw new AgentApiError("Tela API agent listing requires a resolved credential", 0, "");
       }
-      const url = new URL(joinUrl(config.telaApiUrl, "/agent"));
+      const url = new URL(joinUrl2(config.telaApiUrl, "/agent"));
       url.searchParams.set("includeProjects", "true");
       const response = await fetchFn(url.toString(), {
         method: "GET",
@@ -1696,7 +1696,7 @@ var require_agent_api = __commonJS({
     }
     async function listAvailableRepositories(config, fetchFn = fetch) {
       const headers = await (0, auth_1.buildAgentApiHeaders)(config, { fetchFn });
-      const response = await fetchFn(joinUrl(config.agentApiUrl, "/v3/agents/repositories"), {
+      const response = await fetchFn(joinUrl2(config.agentApiUrl, "/v3/agents/repositories"), {
         method: "GET",
         headers,
         signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS)
@@ -1803,13 +1803,13 @@ var require_claude = __commonJS({
       minor: 1,
       patch: 108
     };
-    function isRecord(value) {
+    function isRecord2(value) {
       return Boolean(value && typeof value === "object" && !Array.isArray(value));
     }
     function parseClaudeSettings(path, content) {
       try {
         const parsed = JSON.parse(content);
-        if (isRecord(parsed)) {
+        if (isRecord2(parsed)) {
           return parsed;
         }
       } catch (error) {
@@ -1831,7 +1831,7 @@ var require_claude = __commonJS({
     }
     function readAllowedPermissionRules(settings, settingsPath) {
       const permissions = settings.permissions;
-      if (!isRecord(permissions) || !Array.isArray(permissions.allow) || permissions.allow.length === 0) {
+      if (!isRecord2(permissions) || !Array.isArray(permissions.allow) || permissions.allow.length === 0) {
         throw (0, errors_1.createUserFacingError)({
           code: "claude_project_permissions_missing",
           summary: "Agent repository is missing Claude project tool permissions.",
@@ -3300,7 +3300,7 @@ var require_run = __commonJS({
     function safeNumber(value) {
       return typeof value === "number" && Number.isFinite(value) ? value : void 0;
     }
-    function isRecord(value) {
+    function isRecord2(value) {
       return Boolean(value) && typeof value === "object" && !Array.isArray(value);
     }
     function formatDurationMs(durationMs) {
@@ -3327,11 +3327,11 @@ var require_run = __commonJS({
       return `${minutes}m ${remainder}s`;
     }
     function summarizePermissionDenial(value) {
-      if (!isRecord(value)) {
+      if (!isRecord2(value)) {
         return "Permission denied for a tool call.";
       }
       const toolName = safeString(value.tool_name) ?? "tool";
-      if (!isRecord(value.tool_input)) {
+      if (!isRecord2(value.tool_input)) {
         return `Permission denied: ${toolName}`;
       }
       const inputSummary = summarizeToolInput(toolName, value.tool_input);
@@ -3361,7 +3361,7 @@ var require_run = __commonJS({
       return value !== void 0;
     }
     function summarizeToolInput(toolName, input) {
-      if (!isRecord(input)) {
+      if (!isRecord2(input)) {
         return void 0;
       }
       const pathValue = [
@@ -3443,7 +3443,7 @@ var require_run = __commonJS({
         return "";
       }
       return content.flatMap((block) => {
-        if (!isRecord(block) || block.type !== "text") {
+        if (!isRecord2(block) || block.type !== "text") {
           return [];
         }
         return typeof block.text === "string" ? [block.text] : [];
@@ -3458,7 +3458,7 @@ var require_run = __commonJS({
         return [];
       }
       return content.flatMap((block, index) => {
-        if (!isRecord(block) || block.type !== "tool_use") {
+        if (!isRecord2(block) || block.type !== "tool_use") {
           return [];
         }
         const name = safeString(block.name);
@@ -3613,7 +3613,7 @@ var require_run = __commonJS({
               }];
             }
             case "files_persisted": {
-              const failed = Array.isArray(event.failed) ? event.failed.filter(isRecord) : [];
+              const failed = Array.isArray(event.failed) ? event.failed.filter(isRecord2) : [];
               if (failed.length === 0) {
                 const persistedCount = Array.isArray(event.files) ? event.files.length : 0;
                 return [{
@@ -3673,7 +3673,7 @@ var require_run = __commonJS({
             return [];
           const events = [];
           for (const block of content) {
-            if (!isRecord(block) || block.type !== "tool_result")
+            if (!isRecord2(block) || block.type !== "tool_result")
               continue;
             const toolUseId = safeString(block.tool_use_id);
             if (!toolUseId)
@@ -3684,7 +3684,7 @@ var require_run = __commonJS({
               output = blockContent;
             } else if (Array.isArray(blockContent)) {
               output = blockContent.flatMap((part) => {
-                if (!isRecord(part))
+                if (!isRecord2(part))
                   return [];
                 if (typeof part.text === "string")
                   return [part.text];
@@ -3777,7 +3777,7 @@ var require_run = __commonJS({
       return `<step${elapsed}>${escapeReasoningStepContent(content)}</step>`;
     }
     function normalizeToolInput(input) {
-      if (isRecord(input)) {
+      if (isRecord2(input)) {
         return input;
       }
       if (input === void 0) {
@@ -3870,7 +3870,7 @@ var require_run = __commonJS({
         }
       }
       registerSubagentBucket(tool) {
-        const input = isRecord(tool.input) ? tool.input : {};
+        const input = isRecord2(tool.input) ? tool.input : {};
         const agentType = safeString(input.subagent_type) ?? safeString(input.agent_type) ?? "subagent";
         const description = safeString(input.description) ?? "";
         const prompt = safeString(input.prompt);
@@ -3889,7 +3889,7 @@ var require_run = __commonJS({
       isSubagentTool(name, input) {
         if (name === "Task" || name === "Agent")
           return true;
-        if (isRecord(input) && typeof input.subagent_type === "string")
+        if (isRecord2(input) && typeof input.subagent_type === "string")
           return true;
         return false;
       }
@@ -5472,7 +5472,7 @@ var require_setup = __commonJS({
     function toObject(value) {
       return value && typeof value === "object" ? value : null;
     }
-    function stringValue(value) {
+    function stringValue2(value) {
       return typeof value === "string" && value.trim() ? value.trim() : void 0;
     }
     function loadSshPublicKey(filePath) {
@@ -5555,9 +5555,9 @@ var require_setup = __commonJS({
       const raw = toObject(credential?.raw);
       const rawUser = toObject(raw?.user);
       const user = {
-        id: stringValue(rawUser?.id),
-        email: stringValue(rawUser?.email) ?? fallbackEmail,
-        name: stringValue(rawUser?.name) ?? stringValue(rawUser?.title) ?? stringValue(rawUser?.email) ?? fallbackEmail
+        id: stringValue2(rawUser?.id),
+        email: stringValue2(rawUser?.email) ?? fallbackEmail,
+        name: stringValue2(rawUser?.name) ?? stringValue2(rawUser?.title) ?? stringValue2(rawUser?.email) ?? fallbackEmail
       };
       return user.id || user.email || user.name ? user : void 0;
     }
@@ -6640,8 +6640,8 @@ var require_dist2 = __commonJS({
 });
 
 // src/program.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
+var import_node_fs2 = require("node:fs");
+var import_node_path2 = require("node:path");
 var import_tela_agent = __toESM(require_dist2());
 
 // src/output.ts
@@ -6930,20 +6930,745 @@ function writeDoctorHelp(io) {
 }
 
 // src/commands/env.ts
+var import_tela_local_config6 = __toESM(require_dist());
+
+// src/commands/ingredients.ts
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
 var import_tela_local_config5 = __toESM(require_dist());
+var PANTRY_BASE_URL = "https://pantry-api.tela.tools";
+var INGREDIENT_PAGE_LIMIT = 100;
+var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+var FALLBACK_ENVIRONMENT_ORDER = ["tooling", "production", "staging", "development"];
+var PANTRY_INGREDIENT = {
+  slug: "pantry",
+  name: "Pantry",
+  description: "Ingredient registry and API catalog",
+  type: "api",
+  status: "active",
+  environments: [{ slug: "production", url: PANTRY_BASE_URL }]
+};
+async function runTelactlCommand(command, args, options, io) {
+  try {
+    if (command === "update") return updateIngredients(args, options, io);
+    if (command === "api") return callIngredientApi(args, options, io);
+    if (command === "docs") return runDocsCommand(args, options, io);
+    if (command === "whoami") return whoami(args, options, io);
+    if (command === "token") return tokenAlias(args, options, io);
+    writeError(io, `Unknown telactl command: ${command}`);
+    return 1;
+  } catch (error) {
+    writeError(io, error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+async function runIngredientEnvCommand(args, options, io) {
+  const [action, ...rest] = args;
+  if (action === "set") return setIngredientEnvironment(rest, io);
+  if (action === "list" && rest.some((arg) => !arg.startsWith("-"))) return listIngredientEnvironments(rest, options, io);
+  return null;
+}
+async function updateIngredients(args, options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  if (flags.rest.length > 0) return usageError(`Unknown update argument: ${flags.rest[0]}`, io);
+  const session = await loadSession(flags.contextId);
+  const cache = {
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ingredients: await fetchIngredientCatalog(requestHeaders(session.credential))
+  };
+  await writeCache(cache);
+  if (options.json) {
+    writeJson(io, {
+      cache: {
+        updatedAt: cache.updatedAt,
+        ingredientCount: cache.ingredients.length,
+        contextId: session.resolved.id,
+        refreshed: session.refreshed
+      }
+    });
+    return 0;
+  }
+  writeLine(io, `Cached ${cache.ingredients.length} ingredients`);
+  return 0;
+}
+async function callIngredientApi(args, _options, io) {
+  const flags = parseApiFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  const [slug, method, routePath, ...httpieArgs] = flags.rest;
+  if (!slug || !method || !routePath) {
+    return usageError("Usage: tela api <slug> <METHOD> <PATH> [args...] [--env <slug>] [--body <json>] [-p|--pretty]", io);
+  }
+  if (!HTTP_METHODS.has(method.toUpperCase())) return usageError(`Unsupported HTTP method: ${method}`, io);
+  const ingredient = requireIngredient(slug, "api");
+  const environment = resolveIngredientEnvironment(ingredient, flags.env);
+  if (!environment) {
+    return usageError(`Ingredient '${slug}' has no environments configured. Run \`tela update\` after Pantry is updated.`, io);
+  }
+  const headers = new Headers();
+  const queryParams = [];
+  const fields = {};
+  let hasFields = false;
+  for (const arg of httpieArgs) {
+    const parsed = parseHttpieArg(arg);
+    if (!parsed) return usageError(`Invalid argument '${arg}'. Use Key:Value, name=value, name==value, or name:=rawJson.`, io);
+    if (parsed.kind === "query") {
+      queryParams.push([parsed.key, parsed.value]);
+      continue;
+    }
+    if (parsed.kind === "header") {
+      headers.set(parsed.key.trim(), parsed.value.trim());
+      continue;
+    }
+    if (parsed.kind === "field") {
+      fields[parsed.key] = parsed.value;
+      hasFields = true;
+      continue;
+    }
+    try {
+      fields[parsed.key] = JSON.parse(parsed.value);
+    } catch {
+      return usageError(`Invalid JSON for raw field '${parsed.key}': ${parsed.value}`, io);
+    }
+    hasFields = true;
+  }
+  const url = new URL(joinUrl(environment.url, routePath));
+  for (const [key, value] of queryParams) url.searchParams.append(key, value);
+  const session = await loadSession(flags.contextId);
+  for (const [key, value] of Object.entries(requestHeaders(session.credential))) {
+    if (!headers.has(key)) headers.set(key, value);
+  }
+  if (!headers.has("Accept")) headers.set("Accept", "application/json");
+  let requestBody;
+  if (flags.body !== void 0) {
+    requestBody = flags.body;
+  } else if (hasFields) {
+    requestBody = JSON.stringify(fields);
+  }
+  if (requestBody !== void 0 && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+  const response = await fetch(url, {
+    method: method.toUpperCase(),
+    headers,
+    body: requestBody
+  });
+  const text = await response.text();
+  assertHttpOk(response, text);
+  if (flags.pretty) {
+    const parsed = tryParseJson(text);
+    if (parsed !== null) {
+      writeJson(io, parsed);
+      return 0;
+    }
+  }
+  writeLine(io, text);
+  return 0;
+}
+async function runDocsCommand(args, options, io) {
+  const [action, ...rest] = args;
+  if (!action || action === "help" || action === "--help" || action === "-h") {
+    writeDocsHelp(io);
+    return 0;
+  }
+  if (action === "endpoints") return docsEndpoints(rest, options, io);
+  if (action === "reference") return docsReference(rest, options, io);
+  if (action === "guide") return docsGuide(rest, options, io);
+  return usageError(`Unknown docs command: ${action}`, io);
+}
+async function docsEndpoints(args, options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  const [slug] = flags.rest;
+  if (!slug) return usageError("Usage: tela docs endpoints <slug> [-p|--pretty]", io);
+  requireIngredient(slug, "api");
+  const spec = await fetchOpenApiSpec(slug, flags.contextId);
+  const paths = isRecord(spec.paths) ? spec.paths : {};
+  if (flags.pretty && !options.json) {
+    writeLine(io, formatEndpointsTable(paths));
+    return 0;
+  }
+  writeJson(io, paths);
+  return 0;
+}
+async function docsReference(args, options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  const [slug, first, second] = flags.rest;
+  if (!slug) return usageError("Usage: tela docs reference <slug> [METHOD PATH|file-path] [-p|--pretty]", io);
+  const ingredient = requireIngredient(slug);
+  if (ingredient.type === "api") {
+    if (first && !second && HTTP_METHODS.has(first.toUpperCase())) {
+      return usageError("Both METHOD and PATH are required to show a specific endpoint", io);
+    }
+    const spec = await fetchOpenApiSpec(slug, flags.contextId);
+    if (first && second) {
+      if (!HTTP_METHODS.has(first.toUpperCase())) return usageError(`Unsupported HTTP method: ${first}`, io);
+      const pathEntry = isRecord(spec.paths) && isRecord(spec.paths[second]) ? spec.paths[second] : null;
+      if (!pathEntry) return usageError(`Path not found: ${second}`, io);
+      const op = pathEntry[first.toLowerCase()];
+      if (!op) return usageError(`Method ${first.toUpperCase()} not found for ${second}`, io);
+      if (flags.pretty && !options.json) {
+        writeLine(io, formatEndpoint(spec, op, first, second));
+        return 0;
+      }
+      writeJson(io, op);
+      return 0;
+    }
+    if (flags.pretty && !options.json) {
+      writeJson(io, spec);
+      return 0;
+    }
+    writeLine(io, JSON.stringify(spec));
+    return 0;
+  }
+  if (ingredient.type !== "library") return usageError(`Ingredient '${slug}' is not an API or library ingredient.`, io);
+  const ingredientBody = await fetchIngredient(slug, flags.contextId);
+  const apiRef = isRecord(ingredientBody.docs) ? stringValue(ingredientBody.docs.api) : "";
+  if (!apiRef) return usageError(`Library ${slug} has no API reference`, io);
+  const filePath = extractGitHubFilePath(apiRef);
+  if (!filePath) return usageError(`Could not extract file path from API reference URL: ${apiRef}`, io);
+  const slashIndex = filePath.lastIndexOf("/");
+  const dir = slashIndex === -1 ? "" : filePath.slice(0, slashIndex + 1);
+  const relativePath = first ? first.replace(/^\/+/, "") : "globals.md";
+  const guide = await fetchGuide(slug, `${dir}${relativePath}`, flags.contextId);
+  writeLine(io, stringValue(guide.content));
+  return 0;
+}
+async function docsGuide(args, _options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  const [slug, providedPath] = flags.rest;
+  if (!slug) return usageError("Usage: tela docs guide <slug> [path] [-p|--pretty]", io);
+  const ingredient = requireIngredient(slug);
+  if (ingredient.type !== "api" && ingredient.type !== "library") {
+    return usageError(`Ingredient '${slug}' is not an API or library ingredient.`, io);
+  }
+  const ingredientBody = await fetchIngredient(slug, flags.contextId);
+  const guidesRef = isRecord(ingredientBody.docs) ? stringValue(ingredientBody.docs.guides) : "";
+  if (!guidesRef) return usageError(`Ingredient ${slug} has no guide`, io);
+  const filePath = extractGitHubFilePath(guidesRef);
+  if (!filePath) return usageError(`Could not extract file path from guide URL: ${guidesRef}`, io);
+  const guide = await fetchGuide(slug, resolveGuidePath(filePath, providedPath), flags.contextId);
+  writeLine(io, stringValue(guide.content));
+  return 0;
+}
+async function listIngredientEnvironments(args, options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  const [slug] = flags.rest;
+  if (!slug) return usageError("Usage: tela env list <ingredient-slug> [-p|--pretty|--json]", io);
+  const ingredient = requireIngredient(slug);
+  const environments = ingredient.environments ?? [];
+  if (options.json || !flags.pretty) {
+    writeJson(io, { environments });
+    return 0;
+  }
+  if (environments.length === 0) {
+    writeLine(io, "(no environments configured)");
+    return 0;
+  }
+  const slugWidth = Math.max(...environments.map((environment) => environment.slug.length));
+  for (const environment of environments) {
+    writeLine(io, `${environment.slug.padEnd(slugWidth)}  ${environment.url}`);
+  }
+  return 0;
+}
+async function setIngredientEnvironment(args, io) {
+  const [slug, environment] = args;
+  if (!slug || !environment) return usageError("Usage: tela env set <ingredient-slug> <environment>", io);
+  const ingredient = requireIngredient(slug);
+  if (!ingredient.environments.some((candidate) => candidate.slug === environment)) {
+    const available = ingredient.environments.map((candidate) => candidate.slug).join(", ") || "(none)";
+    return usageError(`Environment '${environment}' not found for '${slug}'. Available: ${available}`, io);
+  }
+  const defaults = await readEnvironmentDefaults();
+  defaults[slug] = environment;
+  await writeEnvironmentDefaults(defaults);
+  writeLine(io, `Set default environment for '${slug}' to '${environment}'`);
+  return 0;
+}
+async function whoami(args, _options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  if (flags.rest.length > 0) return usageError(`Unknown whoami argument: ${flags.rest[0]}`, io);
+  const session = await loadSession(flags.contextId);
+  if (!session.credential.accessToken) {
+    return usageError(`Context ${session.resolved.id} does not have an access token credential.`, io);
+  }
+  const response = await fetch(new URL("/api/auth/applications/whoami", session.resolved.environment.authApiUrl), {
+    headers: {
+      Accept: "application/json",
+      "x-tela-access-token": session.credential.accessToken
+    }
+  });
+  const text = await response.text();
+  assertHttpOk(response, text);
+  if (flags.pretty) {
+    const parsed = tryParseJson(text);
+    if (parsed !== null) {
+      writeJson(io, parsed);
+      return 0;
+    }
+  }
+  writeLine(io, text);
+  return 0;
+}
+async function tokenAlias(args, _options, io) {
+  const flags = parseCommonFlags(args);
+  if ("error" in flags) return usageError(flags.error, io);
+  if (flags.rest.length > 0) return usageError(`Unknown token argument: ${flags.rest[0]}`, io);
+  const session = await loadSession(flags.contextId);
+  if (!session.credential.accessToken) return usageError(`Context ${session.resolved.id} does not have an access token credential.`, io);
+  writeLine(io, session.credential.accessToken);
+  return 0;
+}
+async function fetchOpenApiSpec(slug, contextId) {
+  const session = await loadSession(contextId);
+  const response = await fetch(getPantryOpenapiUrl(slug), {
+    headers: requestHeaders(session.credential)
+  });
+  const text = await response.text();
+  assertHttpOk(response, text, "Failed to fetch OpenAPI spec");
+  const parsed = JSON.parse(text);
+  if (!isRecord(parsed)) throw new Error("OpenAPI response was not a JSON object");
+  return parsed;
+}
+async function fetchIngredient(slug, contextId) {
+  const session = await loadSession(contextId);
+  const response = await fetch(getPantryIngredientUrl(slug), {
+    headers: requestHeaders(session.credential)
+  });
+  const text = await response.text();
+  assertHttpOk(response, text, "Failed to fetch ingredient");
+  const parsed = JSON.parse(text);
+  if (!isRecord(parsed)) throw new Error("Ingredient response was not a JSON object");
+  return parsed;
+}
+async function fetchGuide(slug, filePath, contextId) {
+  const session = await loadSession(contextId);
+  const response = await fetch(getPantryGuideUrl(slug, filePath), {
+    headers: requestHeaders(session.credential)
+  });
+  const text = await response.text();
+  assertHttpOk(response, text, "Failed to fetch guide");
+  const parsed = JSON.parse(text);
+  if (!isRecord(parsed)) throw new Error("Guide response was not a JSON object");
+  return parsed;
+}
+async function loadSession(contextId) {
+  const config = await (0, import_tela_local_config5.loadConfig)();
+  const resolved = (0, import_tela_local_config5.resolveContext)(config, { contextId });
+  const credentials = createCliCredentialAdapter();
+  const credentialRef = resolved.context.credentialRef;
+  const originalCredential = await credentials.get(credentialRef);
+  if (!originalCredential) throw new Error(`Missing credential for Tela context ${resolved.id}`);
+  const credential = originalCredential.kind === "user-session" ? await (0, import_tela_local_config5.refreshUserSessionCredential)(resolved.environment, credentialRef, originalCredential, credentials) : originalCredential;
+  return {
+    resolved,
+    credentialRef,
+    credential,
+    refreshed: credential !== originalCredential
+  };
+}
+function requestHeaders(credential) {
+  if (credential.kind === "data-token" && credential.dataToken) {
+    return {
+      Accept: "application/json",
+      "x-data-token": credential.dataToken
+    };
+  }
+  if (credential.accessToken) {
+    return {
+      Accept: "application/json",
+      Authorization: `Bearer ${credential.accessToken}`
+    };
+  }
+  throw new Error(`Credential ${credential.kind} does not contain usable token material`);
+}
+function requireIngredient(slug, type) {
+  const ingredient = readModules().find((candidate) => candidate.slug === slug);
+  if (!ingredient) throw new Error(`Ingredient '${slug}' not found. Run \`tela update\` first.`);
+  if (type && ingredient.type !== type) throw new Error(`Ingredient '${slug}' is not a ${type} ingredient.`);
+  return ingredient;
+}
+async function fetchIngredientCatalog(headers, fetchImpl = fetch) {
+  const ingredients = [];
+  let total = null;
+  for (let offset = 0; ; offset += INGREDIENT_PAGE_LIMIT) {
+    const url = new URL("/ingredients", PANTRY_BASE_URL);
+    url.searchParams.set("limit", String(INGREDIENT_PAGE_LIMIT));
+    url.searchParams.set("offset", String(offset));
+    const response = await fetchImpl(url.toString(), { headers });
+    const text = await response.text();
+    assertHttpOk(response, text, "Failed to fetch ingredients");
+    const data = JSON.parse(text);
+    const rawPageIngredients = data.ingredients ?? [];
+    const pageIngredients = rawPageIngredients.map(normalizeCachedIngredient).filter((ingredient) => ingredient.slug);
+    ingredients.push(...pageIngredients);
+    total = typeof data.total === "number" ? data.total : total;
+    if (total !== null && ingredients.length >= total) break;
+    if (rawPageIngredients.length < INGREDIENT_PAGE_LIMIT) break;
+  }
+  return ingredients;
+}
+function normalizeCachedIngredient(ingredient) {
+  return {
+    slug: stringValue(ingredient.slug),
+    name: stringValue(ingredient.name),
+    description: stringValue(ingredient.description),
+    type: normalizeIngredientType(ingredient.type),
+    status: stringValue(ingredient.status),
+    environments: (ingredient.environments ?? []).map((environment) => ({
+      slug: environment.slug,
+      url: environment.url
+    })).filter((environment) => environment.slug && environment.url)
+  };
+}
+function readModules() {
+  const cache = readCache();
+  const ingredients = cache?.ingredients ?? [];
+  return ingredients.some((ingredient) => ingredient.slug === PANTRY_INGREDIENT.slug) ? ingredients : [...ingredients, PANTRY_INGREDIENT];
+}
+function readCache() {
+  try {
+    const text = (0, import_node_fs.readFileSync)(cachePath(), "utf8");
+    const parsed = JSON.parse(text);
+    if (!Array.isArray(parsed.ingredients)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(cache) {
+  const filePath = cachePath();
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(filePath), { recursive: true });
+  await (0, import_promises.writeFile)(filePath, `${JSON.stringify(cache, null, 2)}
+`, "utf8");
+}
+function cachePath() {
+  return (0, import_node_path.join)((0, import_tela_local_config5.getTelaLocalPaths)().rootDir, "ingredients.json");
+}
+async function readEnvironmentDefaults() {
+  try {
+    return JSON.parse(await (0, import_promises.readFile)(environmentDefaultsPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeEnvironmentDefaults(defaults) {
+  const filePath = environmentDefaultsPath();
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(filePath), { recursive: true });
+  await (0, import_promises.writeFile)(filePath, `${JSON.stringify(defaults, null, 2)}
+`, "utf8");
+}
+function environmentDefaultsPath() {
+  return (0, import_node_path.join)((0, import_tela_local_config5.getTelaLocalPaths)().rootDir, "ingredient-environments.json");
+}
+function resolveIngredientEnvironment(ingredient, override) {
+  const environments = ingredient.environments ?? [];
+  if (override) {
+    const found = environments.find((environment) => environment.slug === override);
+    if (!found) {
+      const available2 = environments.map((environment) => environment.slug).join(", ") || "(none)";
+      throw new Error(`Environment '${override}' not found for ingredient '${ingredient.slug}'. Available: ${available2}`);
+    }
+    return found;
+  }
+  if (environments.length === 0) return null;
+  if (environments.length === 1) return environments[0] ?? null;
+  const defaults = readEnvironmentDefaultsSync();
+  const saved = defaults[ingredient.slug];
+  if (saved) {
+    const found = environments.find((environment) => environment.slug === saved);
+    if (found) return found;
+  }
+  for (const preferred of FALLBACK_ENVIRONMENT_ORDER) {
+    const found = environments.find((environment) => environment.slug === preferred);
+    if (found) return found;
+  }
+  const available = environments.map((environment) => environment.slug).join(", ");
+  throw new Error(
+    `Multiple environments configured for '${ingredient.slug}' and no default matches.
+Available: ${available}
+Use --env <slug> to pick one, or run \`tela env set ${ingredient.slug} <environment>\` to save a default.`
+  );
+}
+function readEnvironmentDefaultsSync() {
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(environmentDefaultsPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function parseCommonFlags(args) {
+  const flags = {
+    pretty: false,
+    rest: []
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--context") {
+      const value = args[index + 1];
+      if (!value) return { error: "Expected value after --context" };
+      flags.contextId = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--pretty" || arg === "-p") {
+      flags.pretty = true;
+      continue;
+    }
+    flags.rest.push(arg);
+  }
+  return flags;
+}
+function parseApiFlags(args) {
+  const flags = {
+    pretty: false,
+    rest: []
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--context") {
+      const value = args[index + 1];
+      if (!value) return { error: "Expected value after --context" };
+      flags.contextId = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--env") {
+      const value = args[index + 1];
+      if (!value) return { error: "Expected value after --env" };
+      flags.env = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--body") {
+      const value = args[index + 1];
+      if (value === void 0) return { error: "Expected value after --body" };
+      flags.body = value;
+      index += 1;
+      continue;
+    }
+    if (arg === "--pretty" || arg === "-p") {
+      flags.pretty = true;
+      continue;
+    }
+    flags.rest.push(arg);
+  }
+  return flags;
+}
+function joinUrl(base, routePath) {
+  const trimmedBase = base.replace(/\/$/, "");
+  const prefixedPath = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  return `${trimmedBase}${prefixedPath}`;
+}
+function parseHttpieArg(arg) {
+  for (let index = 0; index < arg.length; index += 1) {
+    const two = arg.slice(index, index + 2);
+    if (two === "==") return { kind: "query", key: arg.slice(0, index), value: arg.slice(index + 2) };
+    if (two === ":=") return { kind: "rawField", key: arg.slice(0, index), value: arg.slice(index + 2) };
+    if (arg[index] === ":") return { kind: "header", key: arg.slice(0, index), value: arg.slice(index + 1) };
+    if (arg[index] === "=") return { kind: "field", key: arg.slice(0, index), value: arg.slice(index + 1) };
+  }
+  return null;
+}
+function getPantryOpenapiUrl(slug) {
+  return slug === "pantry" ? `${PANTRY_BASE_URL}/openapi` : `${PANTRY_BASE_URL}/ingredients/${slug}/openapi`;
+}
+function getPantryIngredientUrl(slug) {
+  return `${PANTRY_BASE_URL}/ingredients/${slug}`;
+}
+function getPantryGuideUrl(slug, filePath) {
+  const base = `${PANTRY_BASE_URL}/ingredients/${slug}/guide`;
+  if (!filePath) return base;
+  const params = new URLSearchParams({ path: filePath });
+  return `${base}?${params.toString()}`;
+}
+function formatEndpointsTable(paths) {
+  const lines = [];
+  for (const [routePath, methods] of Object.entries(paths)) {
+    for (const [method, op] of Object.entries(methods)) {
+      if (method.startsWith("x-")) continue;
+      const summary = op.summary ?? op.operationId ?? "";
+      lines.push(`${method.toUpperCase().padEnd(7)} ${routePath}  ${summary}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatEndpoint(spec, op, method, routePath) {
+  if (!isRecord(op)) return "";
+  const lines = [`${method.toUpperCase()} ${routePath}`];
+  if (typeof op.summary === "string") lines.push(`
+${op.summary}`);
+  if (typeof op.description === "string" && op.description !== op.summary) lines.push(op.description);
+  const parameters = Array.isArray(op.parameters) ? op.parameters : [];
+  if (parameters.length > 0) {
+    lines.push("\n## Parameters\n");
+    for (const parameter of parameters) {
+      const resolved = isRecord(parameter) && typeof parameter.$ref === "string" ? resolveRef(spec, parameter.$ref) : parameter;
+      if (!isRecord(resolved)) continue;
+      const required = resolved.required ? " (required)" : "";
+      const description = typeof resolved.description === "string" ? ` - ${resolved.description}` : "";
+      const schema = isRecord(resolved.schema) ? resolved.schema : {};
+      const type = typeof schema.type === "string" ? schema.type : "";
+      lines.push(`  ${stringValue(resolved.in)}  ${stringValue(resolved.name)}: ${type}${required}${description}`);
+    }
+  }
+  if (isRecord(op.requestBody)) {
+    lines.push("\n## Request Body\n");
+    const content = isRecord(op.requestBody.content) ? op.requestBody.content : {};
+    for (const [contentType, media] of Object.entries(content)) {
+      if (!isRecord(media)) continue;
+      lines.push(`  Content-Type: ${contentType}`);
+      const schema = resolveSchema(spec, media.schema);
+      if (schema) lines.push(formatSchema(schema, 1));
+    }
+  }
+  if (isRecord(op.responses)) {
+    lines.push("\n## Responses\n");
+    for (const [status, response] of Object.entries(op.responses)) {
+      const resolved = isRecord(response) && typeof response.$ref === "string" ? resolveRef(spec, response.$ref) : response;
+      if (!isRecord(resolved)) continue;
+      lines.push(`  ${status}: ${stringValue(resolved.description)}`);
+      const content = isRecord(resolved.content) ? resolved.content : {};
+      for (const media of Object.values(content)) {
+        if (!isRecord(media)) continue;
+        const schema = resolveSchema(spec, media.schema);
+        if (schema) lines.push(formatSchema(schema, 2));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function resolveRef(spec, ref) {
+  const parts = ref.replace("#/", "").split("/");
+  let current = spec;
+  for (const part of parts) {
+    current = isRecord(current) ? current[part] : void 0;
+  }
+  return current;
+}
+function resolveSchema(spec, schema) {
+  if (!isRecord(schema)) return null;
+  if (typeof schema.$ref === "string") return resolveSchema(spec, resolveRef(spec, schema.$ref));
+  if (schema.items) return { ...schema, items: resolveSchema(spec, schema.items) };
+  if (isRecord(schema.properties)) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(schema.properties)) {
+      resolved[key] = resolveSchema(spec, value) ?? value;
+    }
+    return { ...schema, properties: resolved };
+  }
+  return schema;
+}
+function formatSchema(schema, indent = 0) {
+  if (!schema) return "";
+  const pad = "  ".repeat(indent);
+  if (schema.type === "object" && isRecord(schema.properties)) {
+    const requiredFields = Array.isArray(schema.required) ? schema.required.filter((item) => typeof item === "string") : [];
+    return Object.entries(schema.properties).map(([key, prop]) => {
+      if (!isRecord(prop)) return `${pad}${key}: unknown`;
+      const required = requiredFields.includes(key) ? "" : "?";
+      const type = typeof prop.type === "string" ? prop.type : "object";
+      const description = typeof prop.description === "string" ? ` - ${prop.description}` : "";
+      if (prop.type === "object" && isRecord(prop.properties)) {
+        return `${pad}${key}${required}: {${description}
+${formatSchema(prop, indent + 1)}
+${pad}}`;
+      }
+      if (prop.type === "array" && isRecord(prop.items)) {
+        const itemType = typeof prop.items.type === "string" ? prop.items.type : "object";
+        return `${pad}${key}${required}: ${itemType}[]${description}`;
+      }
+      return `${pad}${key}${required}: ${type}${description}`;
+    }).join("\n");
+  }
+  return `${pad}${typeof schema.type === "string" ? schema.type : "unknown"}`;
+}
+function extractGitHubFilePath(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  const parts = parsed.pathname.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+  if (parsed.hostname === "github.com") {
+    const [owner, repo, scope, ref, ...filePathParts] = parts;
+    if (!owner || !repo || scope !== "blob" || !ref || filePathParts.length === 0) return null;
+    return filePathParts.join("/");
+  }
+  if (parsed.hostname === "raw.githubusercontent.com") {
+    const [owner, repo, firstRefPart, ...rest] = parts;
+    if (!owner || !repo || !firstRefPart) return null;
+    if (firstRefPart === "refs") {
+      const [, , ...filePathParts] = rest;
+      return filePathParts.length > 0 ? filePathParts.join("/") : null;
+    }
+    return rest.length > 0 ? rest.join("/") : null;
+  }
+  return null;
+}
+function resolveGuidePath(rootFilePath, providedPath) {
+  const slashIndex = rootFilePath.lastIndexOf("/");
+  const dir = slashIndex === -1 ? "" : rootFilePath.slice(0, slashIndex + 1);
+  const basename = slashIndex === -1 ? rootFilePath : rootFilePath.slice(slashIndex + 1);
+  const relativePath = providedPath ? providedPath.replace(/^\/+/, "") : basename;
+  return `${dir}${relativePath}`;
+}
+function assertHttpOk(response, bodyText, context) {
+  if (response.ok) return;
+  const prefix = context ? `${context}: ` : "";
+  throw new Error(`${prefix}${response.status} ${response.statusText}${bodyText ? `
+${bodyText}` : ""}`);
+}
+function usageError(message, io) {
+  writeError(io, message);
+  return 1;
+}
+function writeDocsHelp(io) {
+  writeLine(io, "Usage: tela docs <command> [args]");
+  writeLine(io);
+  writeLine(io, "Commands:");
+  writeLine(io, "  docs endpoints <slug> [-p|--pretty] [--json]");
+  writeLine(io, "  docs reference <slug> [METHOD PATH|file-path] [-p|--pretty] [--json]");
+  writeLine(io, "  docs guide <slug> [path] [-p|--pretty]");
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : "";
+}
+function normalizeIngredientType(value) {
+  if (value === "library" || value === "skill") return value;
+  return "api";
+}
+
+// src/commands/env.ts
 async function runEnvCommand(args, options, io) {
   const [action] = args;
   if (!action || action === "help" || action === "--help" || action === "-h") {
     writeEnvHelp(io);
     return 0;
   }
+  const ingredientResult = await runIngredientEnvCommand(args, options, io);
+  if (ingredientResult !== null) return ingredientResult;
   if (action === "list") return listEnvironments(options, io);
   writeError(io, `Unknown env command: ${action}`);
   return 1;
 }
 async function listEnvironments(options, io) {
-  const config = await (0, import_tela_local_config5.loadConfig)();
-  const publicConfig = await (0, import_tela_local_config5.toPublicConfig)(config, createCliCredentialAdapter());
+  const config = await (0, import_tela_local_config6.loadConfig)();
+  const publicConfig = await (0, import_tela_local_config6.toPublicConfig)(config, createCliCredentialAdapter());
   const environments = Object.values(publicConfig.environments);
   if (options.json) {
     writeJson(io, { environments });
@@ -6957,6 +7682,8 @@ async function listEnvironments(options, io) {
 }
 function writeEnvHelp(io) {
   writeLine(io, "Usage: tela env list [--json]");
+  writeLine(io, "Usage: tela env list <ingredient-slug> [-p|--pretty|--json]");
+  writeLine(io, "Usage: tela env set <ingredient-slug> <environment>");
 }
 
 // src/program.ts
@@ -6976,6 +7703,9 @@ async function runCli(argv, io) {
   if (command === "env") return runEnvCommand(rest, options, io);
   if (command === "doctor") return runDoctorCommand(rest, options, io);
   if (command === "agent") return (0, import_tela_agent.runAgentCli)(rest, io, options);
+  if (command === "update" || command === "api" || command === "docs" || command === "whoami" || command === "token") {
+    return runTelactlCommand(command, rest, options, io);
+  }
   writeError(io, `Unknown command: ${command}`);
   return 1;
 }
@@ -7005,7 +7735,16 @@ function writeHelp(io) {
   writeLine(io, "  context show <context-id> [--json]");
   writeLine(io, "  context use <context-id> [--json]");
   writeLine(io, "  env list [--json]");
+  writeLine(io, "  env list <ingredient-slug> [-p|--pretty|--json]");
+  writeLine(io, "  env set <ingredient-slug> <environment>");
   writeLine(io, "  doctor auth [--json]");
+  writeLine(io, "  update [--context <context-id>] [--json]");
+  writeLine(io, "  api <slug> <METHOD> <PATH> [args...] [--env <slug>] [--body <json>] [-p|--pretty]");
+  writeLine(io, "  docs endpoints <slug> [-p|--pretty] [--json]");
+  writeLine(io, "  docs reference <slug> [METHOD PATH|file-path] [-p|--pretty] [--json]");
+  writeLine(io, "  docs guide <slug> [path] [-p|--pretty]");
+  writeLine(io, "  whoami [--context <context-id>] [-p|--pretty]");
+  writeLine(io, "  token [--context <context-id>]");
   writeLine(io, "  version");
   writeLine(io, "  agent sync [repo] [--current] [--all] [--dry-run] [--json] [--verbose]");
   writeLine(io, "  agent run [--input <name=path>...] [--mode one-shot|chat] [--input-conflict fail|overwrite|rename] [--plain] [--json] [--verbose]");
@@ -7014,7 +7753,7 @@ function writeHelp(io) {
   writeLine(io, "  agent setup [--list-options] [--context <context-id>] [--organization <id-or-name>] [--clone-root <path>] [--ssh-public-key <path>] [--ssh-private-key <path>] [--dry-run] [--json]");
 }
 function getPackageVersion() {
-  const metadata = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "..", "package.json"), "utf8"));
+  const metadata = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(__dirname, "..", "package.json"), "utf8"));
   return typeof metadata.version === "string" ? metadata.version : "0.0.0";
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/tela-cli",
-  "version": "0.7.23",
+  "version": "0.7.25",
   "description": "Tela command line tools for local state and agent workflows.",
   "license": "UNLICENSED",
   "repository": {

package/skills/tela-cli/SKILL.md

@@ -1,12 +1,13 @@
 ---
 name: tela-cli
-description: Use when a coding agent needs to operate Tela Agent repositories through the local `tela` CLI with non-interactive, flag-driven commands and JSON output.
+description: Use when a coding agent needs to operate Tela Agent repositories or Tela Pantry/service ingredients through the local `tela` CLI with non-interactive, flag-driven commands and JSON output.
 ---
 
 # Tela CLI
 
-Use the local `tela` binary for Tela Agent repository workflows. Prefer explicit
-flags and `--json` so commands are safe in non-interactive agent sessions.
+Use the local `tela` binary for Tela Agent repository workflows and Pantry-backed
+service/library discovery. Prefer explicit flags and `--json` so commands are
+safe in non-interactive agent sessions.
 
 ## Subpaths
 
@@ -15,6 +16,28 @@ flags and `--json` so commands are safe in non-interactive agent sessions.
 ## Core Rules
 
 - Use `tela agent ...` commands, not legacy top-level `sync`, `run`, `push`, or `feedback`.
+- Run `tela update` before relying on ingredient slugs; it refreshes the local Pantry cache under `TELA_HOME`.
+- Query Pantry before building a service integration from scratch: `tela api pantry GET /ingredients query==<term>`.
+- Read endpoint or library docs before calling a service: `tela docs endpoints <slug>` then `tela docs reference <slug> <METHOD> <PATH>`.
 - Prefer `--json` for machine-readable output and errors.
 - Do not rely on prompts in coding-agent sessions; pass every required value by flag.
 - Do not print token material. Use `tela auth token --json` for metadata and `--raw` only when a shell command explicitly needs the token.
+
+## Pantry and Service Commands
+
+```bash
+tela update --json
+tela api <slug> <METHOD> <PATH> [args...] --env <slug> --body <json> --pretty
+tela docs endpoints <slug> --pretty
+tela docs reference <slug> [METHOD PATH|file-path] --pretty
+tela docs guide <slug> [path]
+tela env list <ingredient-slug> --pretty
+tela env set <ingredient-slug> <environment>
+```
+
+HTTPie-style args for `tela api`:
+
+- `name=value` sends a JSON string field.
+- `name:=value` sends a raw JSON field.
+- `name==value` sends a query parameter.
+- `Header:value` sends a request header.