llm-cli-gateway 2.4.0 → 2.5.0

package/dist/index.js

@@ -2,7 +2,8 @@
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { randomUUID } from "crypto";
-import { existsSync, readFileSync, readdirSync, renameSync, unlinkSync } from "fs";
+import { createRequire } from "module";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync, chmodSync, } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod/v3";
@@ -17,7 +18,7 @@ import { createWorktree, createWorktreeSessionCleanupHook, } from "./worktree-ma
 import { ResourceProvider } from "./resources.js";
 import { PerformanceMetrics } from "./metrics.js";
 import { estimateTokens, optimizePrompt as optimizePromptText, optimizeResponse as optimizeResponseText, } from "./optimizer.js";
-import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvidersConfig, isXaiProviderEnabled, minStableTokensForModel, } from "./config.js";
+import { loadConfig, loadPersistenceConfig, loadCacheAwarenessConfig, loadProvidersConfig, defaultGatewayConfigPath, isXaiProviderEnabled, minStableTokensForModel, } from "./config.js";
 import { createXaiResponse, XaiApiError, } from "./xai-api-provider.js";
 import { checkHealth } from "./health.js";
 import { clearModelRegistryCache, getAvailableCliInfo, getCliInfo, resolveModelAlias, } from "./model-registry.js";
@@ -32,7 +33,10 @@ import { resolvePromptInput, PromptPartsSchema, assembleClaudeCacheBlocks, } fro
 import { computeSessionCacheStats, computeTtlRemaining, readPersistedRequest, PERSISTED_REQUEST_DEFAULT_MAX_CHARS, } from "./cache-stats.js";
 import { getCliVersions, runCliUpgrade } from "./cli-updater.js";
 import { startHttpGateway } from "./http-transport.js";
+import { getRequestContext } from "./request-context.js";
 import { printDoctorJson } from "./doctor.js";
+import { createWorkspace, describeWorkspace, getWorkspace, loadWorkspaceRegistry, registerExistingWorkspace, resolveWorkspaceForProvider, validatePathInsideWorkspace, } from "./workspace-registry.js";
+import { generateSecret, hashSecret } from "./oauth.js";
 import { registerValidationTools } from "./validation-tools.js";
 import { assertUpstreamCliArgs, assertUpstreamCliEnv, buildProviderSubcommandsCompactCatalog, buildUpstreamContractReport, getCliSubcommandContract, probeInstalledCliContract, serializeCliSubcommandContract, } from "./upstream-contracts.js";
 import { entrypointFileURL } from "./entrypoint-url.js";
@@ -252,6 +256,12 @@ export const WORKTREE_SCHEMA = z
     "path. NOTE: callers should `.gitignore` the `.worktrees/` " +
     "directory in their repo (the gateway does NOT auto-gitignore — " +
     "see slice λ spec Q4).");
+export const WORKSPACE_ALIAS_SCHEMA = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z][A-Za-z0-9._-]{0,63}$/)
+    .describe("Registered workspace alias. Remote clients use aliases, not absolute paths.");
 export const SESSION_PROVIDER_VALUES = PROVIDER_TYPES;
 export const SESSION_PROVIDER_ENUM = z.enum(SESSION_PROVIDER_VALUES);
 let activeServer = null;
@@ -286,6 +296,7 @@ export function resolveGatewayServerRuntime(deps = {}, options = {}) {
         persistence: deps.persistence ?? getPersistenceConfig(runtimeLogger),
         cacheAwareness: deps.cacheAwareness ?? getCacheAwarenessConfig(runtimeLogger),
         providers: deps.providers ?? getProvidersConfig(runtimeLogger),
+        workspaces: deps.workspaces ?? loadWorkspaceRegistry(runtimeLogger),
     };
 }
 export function shouldRegisterGrokApiTools(providers) {
@@ -415,7 +426,7 @@ function buildDeferredToolResponse(deferred, sessionId) {
         ],
     };
 }
-export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime) {
+export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime, options = {}) {
     if (!worktreeOpt)
         return {};
     const sessionManager = runtime.sessionManager;
@@ -423,12 +434,21 @@ export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime)
         const session = await Promise.resolve(sessionManager.getSession(sessionId));
         const existingPath = session?.metadata?.worktreePath;
         if (typeof existingPath === "string" && existingPath.length > 0) {
-            return { cwd: existingPath, worktreePath: existingPath };
+            return {
+                cwd: existingPath,
+                worktreePath: existingPath,
+                workspaceAlias: typeof session?.metadata?.workspaceAlias === "string"
+                    ? session.metadata.workspaceAlias
+                    : options.workspaceAlias,
+                workspaceRoot: typeof session?.metadata?.workspaceRoot === "string"
+                    ? session.metadata.workspaceRoot
+                    : options.workspaceRoot,
+            };
         }
     }
     const name = worktreeOpt === true ? undefined : worktreeOpt.name;
     const ref = worktreeOpt === true ? undefined : worktreeOpt.ref;
-    const repoRoot = process.cwd();
+    const repoRoot = options.repoRoot ?? process.cwd();
     const handle = await createWorktree({
         repoRoot,
         name,
@@ -439,13 +459,204 @@ export async function resolveWorktreeForRequest(worktreeOpt, sessionId, runtime)
         await Promise.resolve(sessionManager.updateSessionMetadata(sessionId, {
             worktreePath: handle.path,
             worktreeName: handle.name,
+            ...(options.workspaceAlias ? { workspaceAlias: options.workspaceAlias } : {}),
+            ...(options.workspaceRoot ? { workspaceRoot: options.workspaceRoot } : {}),
+        }));
+    }
+    return {
+        cwd: handle.path,
+        worktreePath: handle.path,
+        workspaceAlias: options.workspaceAlias,
+        workspaceRoot: options.workspaceRoot,
+    };
+}
+function isGatewayAppDirCwd() {
+    return process.cwd() === join(homedir(), ".llm-cli-gateway");
+}
+async function resolveWorkspaceAndWorktreeForRequest(args) {
+    const session = args.sessionId
+        ? await Promise.resolve(args.runtime.sessionManager.getSession(args.sessionId))
+        : null;
+    let workspace;
+    if (args.workspace ||
+        args.runtime.workspaces.defaultAlias ||
+        typeof session?.metadata?.workspaceAlias === "string") {
+        workspace = resolveWorkspaceForProvider(args.runtime.workspaces, args.provider, args.workspace, session?.metadata);
+    }
+    else if (isGatewayAppDirCwd()) {
+        throw new Error("No workspace selected. Configure [workspaces].default or pass a registered workspace alias.");
+    }
+    if (!workspace && getRequestContext()?.authKind === "oauth") {
+        throw new Error("Remote OAuth provider requests require a registered workspace alias or [workspaces].default.");
+    }
+    if (!workspace &&
+        (args.workingDir || (args.addDir?.length ?? 0) > 0) &&
+        !args.runtime.workspaces.allowUnregisteredWorkingDir) {
+        throw new Error("workingDir/addDir require a registered workspace alias unless [workspaces].allow_unregistered_working_dir is explicitly enabled.");
+    }
+    if (workspace) {
+        if (args.workingDir) {
+            validatePathInsideWorkspace(workspace, args.workingDir, "workingDir");
+        }
+        for (const dir of args.addDir ?? []) {
+            validatePathInsideWorkspace(workspace, dir, "addDir");
+        }
+    }
+    if (args.worktree) {
+        if (workspace && !workspace.repo.allowWorktree) {
+            throw new Error(`Workspace "${workspace.alias}" does not allow worktree requests`);
+        }
+        const resolved = await resolveWorktreeForRequest(args.worktree, args.sessionId, args.runtime, {
+            repoRoot: workspace?.root,
+            workspaceAlias: workspace?.alias,
+            workspaceRoot: workspace?.root,
+        });
+        return { cwd: resolved.cwd, worktreePath: resolved.worktreePath, workspace };
+    }
+    if (workspace && args.sessionId) {
+        await Promise.resolve(args.runtime.sessionManager.updateSessionMetadata(args.sessionId, {
+            workspaceAlias: workspace.alias,
+            workspaceRoot: workspace.root,
         }));
     }
-    return { cwd: handle.path, worktreePath: handle.path };
+    return { cwd: workspace?.cwd, workspace };
 }
 export function formatWorktreePrefix(worktreePath) {
     return worktreePath ? `[gateway] worktree=${worktreePath}\n` : "";
 }
+function workspaceAdminEnabled() {
+    const scopes = getRequestContext()?.authScopes ?? [];
+    return process.env.LLM_GATEWAY_WORKSPACE_ADMIN === "1" && scopes.includes("workspace:admin");
+}
+function registerWorkspaceTools(server, runtime) {
+    server.tool("workspace_list", "List registered workspace aliases and summary metadata. Does not browse files.", {}, {
+        title: "List workspaces",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async () => {
+        const registry = loadWorkspaceRegistry(runtime.logger);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: true,
+                        enabled: registry.enabled,
+                        default: registry.defaultAlias,
+                        workspaces: registry.repos.map(describeWorkspace),
+                        allowed_roots: registry.allowedRoots.map(root => ({
+                            alias: root.alias,
+                            path: root.path,
+                            allow_register_existing_git_repos: root.allowRegisterExistingGitRepos,
+                            allow_create_directories: root.allowCreateDirectories,
+                            allow_init_git_repos: root.allowInitGitRepos,
+                            max_create_depth: root.maxCreateDepth,
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.tool("workspace_get", "Inspect a registered workspace alias. Does not list files.", { alias: WORKSPACE_ALIAS_SCHEMA }, {
+        title: "Get workspace",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    }, async ({ alias }) => {
+        try {
+            const registry = loadWorkspaceRegistry(runtime.logger);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, workspace: describeWorkspace(getWorkspace(registry, alias)) }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return createErrorResponse("workspace_get", 1, "", undefined, error);
+        }
+    });
+    server.tool("workspace_create", "Create a new local folder or git repo under a configured allowed root. Requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin.", {
+        alias: WORKSPACE_ALIAS_SCHEMA,
+        root: WORKSPACE_ALIAS_SCHEMA.describe("Allowed-root alias from workspace_list."),
+        slug: z.string().min(1).max(255).describe("Safe relative path under the allowed root."),
+        kind: z.enum(["folder", "git"]).default("git"),
+        setDefault: z.boolean().default(false),
+    }, {
+        title: "Create workspace",
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+    }, async ({ alias, root, slug, kind, setDefault }) => {
+        try {
+            if (!workspaceAdminEnabled()) {
+                throw new Error("workspace_create requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin");
+            }
+            const repo = createWorkspace({
+                alias,
+                rootAlias: root,
+                slug,
+                kind,
+                setDefault,
+                logger: runtime.logger,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, workspace: describeWorkspace(repo) }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return createErrorResponse("workspace_create", 1, "", undefined, error);
+        }
+    });
+    server.tool("workspace_register_existing_repo", "Register an existing local Git repo under an allowed root. Requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin.", {
+        alias: WORKSPACE_ALIAS_SCHEMA,
+        path: z
+            .string()
+            .min(1)
+            .describe("Absolute path to an existing Git repo under an allowed root."),
+        setDefault: z.boolean().default(false),
+    }, {
+        title: "Register workspace",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    }, async ({ alias, path, setDefault }) => {
+        try {
+            if (!workspaceAdminEnabled()) {
+                throw new Error("workspace_register_existing_repo requires LLM_GATEWAY_WORKSPACE_ADMIN=1 and OAuth scope workspace:admin");
+            }
+            const repo = registerExistingWorkspace({
+                alias,
+                repoPath: path,
+                setDefault,
+                logger: runtime.logger,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ success: true, workspace: describeWorkspace(repo) }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return createErrorResponse("workspace_register_existing_repo", 1, "", undefined, error);
+        }
+    });
+}
 function createErrorResponse(cli, code, stderr, correlationId, error) {
     let errorMessage = `Error executing ${cli} CLI`;
     const isLaunchExit = code === 127 || code === -4058;
@@ -2016,6 +2227,7 @@ function resolveHandlerRuntime(deps) {
         sessionManager: deps.sessionManager,
         logger: normalizedLogger,
         asyncJobManager: asyncDeps.asyncJobManager,
+        workspaces: deps.workspaces,
     });
 }
 export async function handleGeminiRequest(deps, params) {
@@ -2071,13 +2283,20 @@ export async function handleGeminiRequest(deps, params) {
         args.push(...sessionPlan.args);
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionIdHint, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "gemini",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionIdHint,
+                runtime,
+                addDir: params.includeDirs,
+            });
         }
         catch (err) {
             return createErrorResponse("gemini_request", 1, "", corrId, err);
         }
         const geminiFrHandoff = buildAsyncFlightRecorderHandoff("gemini", prep, params.sessionId, params.outputFormat);
-        const result = await awaitJobOrDefer("gemini", args, corrId, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, geminiFrHandoff.flightRecorderEntry, geminiFrHandoff.extractUsage, worktreeResolution.cwd);
+        const result = await awaitJobOrDefer("gemini", args, corrId, resolveIdleTimeout("gemini", params.idleTimeoutMs), params.outputFormat, params.forceRefresh, runtime, undefined, undefined, geminiFrHandoff.flightRecorderEntry, geminiFrHandoff.extractUsage, undefined, worktreeResolution.cwd);
         if (isDeferredResponse(result)) {
             return buildDeferredToolResponse(result, effectiveSessionIdHint);
         }
@@ -2209,7 +2428,14 @@ export async function handleGeminiRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "gemini",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                addDir: params.includeDirs,
+            });
         }
         catch (err) {
             return createErrorResponse("gemini_request_async", 1, "", corrId, err);
@@ -2322,7 +2548,14 @@ export async function handleGrokRequest(deps, params) {
         args.push(...sessionResult.resumeArgs);
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, sessionResult.effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "grok",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: sessionResult.effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+            });
         }
         catch (err) {
             return createErrorResponse("grok_request", 1, "", corrId, err);
@@ -2490,7 +2723,14 @@ export async function handleGrokRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "grok",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+            });
         }
         catch (err) {
             return createErrorResponse("grok_request_async", 1, "", corrId, err);
@@ -2578,7 +2818,15 @@ export async function handleMistralRequest(deps, params) {
         args.push(...sessionResult.resumeArgs);
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, sessionResult.effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "mistral",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: sessionResult.effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+                addDir: params.addDir,
+            });
         }
         catch (err) {
             return createErrorResponse("mistral_request", 1, "", corrId, err);
@@ -2732,7 +2980,15 @@ export async function handleMistralRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "mistral",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+                addDir: params.addDir,
+            });
         }
         catch (err) {
             return createErrorResponse("mistral_request_async", 1, "", corrId, err);
@@ -2844,7 +3100,15 @@ export async function handleCodexRequestAsync(deps, params) {
         }
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(params.worktree, effectiveSessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "codex",
+                workspace: params.workspace,
+                worktree: params.worktree,
+                sessionId: effectiveSessionId,
+                runtime,
+                workingDir: params.workingDir,
+                addDir: params.addDir,
+            });
         }
         catch (err) {
             runPrepCleanupLocally();
@@ -2899,6 +3163,7 @@ export function createGatewayServer(deps = {}) {
     const server = newGatewayMcpServer(asyncJobsEnabled, grokApiToolsEnabled);
     registerBaseResources(server, runtime);
     registerValidationTools(server, { asyncJobManager });
+    registerWorkspaceTools(server, runtime);
     if (grokApiToolsEnabled) {
         server.tool("grok_api_request", "Run an xAI Grok API request synchronously through the Responses API. Requires exactly one of prompt or promptParts. Registered only when [providers.xai] is configured and its API-key env var is present.", {
             prompt: z
@@ -3082,6 +3347,7 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe('Claude --tools: restrict the available built-in tool set (distinct from allowedTools permission gating). Pass [""] to disable all tools.'),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
         approvalStrategy: z
             .enum(["legacy", "mcp_managed"])
@@ -3119,7 +3385,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, }) => {
         const startTime = Date.now();
         if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
             return createErrorResponse("claude", 1, "", correlationId, new Error("systemPrompt and appendSystemPrompt are mutually exclusive; use one or the other (not both)."));
@@ -3214,7 +3480,14 @@ export function createGatewayServer(deps = {}) {
             }
             let worktreeResolution = {};
             try {
-                worktreeResolution = await resolveWorktreeForRequest(worktree, effectiveSessionId, runtime);
+                worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                    provider: "claude",
+                    workspace,
+                    worktree,
+                    sessionId: effectiveSessionId,
+                    runtime,
+                    addDir,
+                });
             }
             catch (err) {
                 return createErrorResponse("claude_request", 1, "", corrId, err);
@@ -3425,6 +3698,7 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe("Codex --add-dir <DIR>: additional writable workspace directories. Emitted once per entry on new sessions only; resume inherits the original session's writable-dir policy."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Codex request",
@@ -3432,7 +3706,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, worktree, }) => {
+    }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, workspace, worktree, }) => {
         const startTime = Date.now();
         const prep = prepareCodexRequest({
             prompt,
@@ -3488,7 +3762,15 @@ export function createGatewayServer(deps = {}) {
         const prepCleanup = "cleanup" in prep && typeof prep.cleanup === "function" ? prep.cleanup : undefined;
         let worktreeResolution = {};
         try {
-            worktreeResolution = await resolveWorktreeForRequest(worktree, sessionId, runtime);
+            worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "codex",
+                workspace,
+                worktree,
+                sessionId,
+                runtime,
+                workingDir,
+                addDir,
+            });
         }
         catch (err) {
             return createErrorResponse("codex_request", 1, "", corrId, err);
@@ -3610,13 +3892,14 @@ export function createGatewayServer(deps = {}) {
             .max(3_600_000)
             .optional()
             .describe("Idle timeout in ms (min 30s, max 1h, omit=CLI default)"),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
     }, {
         title: "Fork Codex session",
         readOnlyHint: false,
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, sessionId, forkLast, model, sandboxMode, askForApproval, correlationId, idleTimeoutMs, }) => {
+    }, async ({ prompt, sessionId, forkLast, model, sandboxMode, askForApproval, correlationId, idleTimeoutMs, workspace, }) => {
         const corrId = correlationId || randomUUID();
         const startTime = Date.now();
         let durationMs = 0;
@@ -3656,7 +3939,13 @@ export function createGatewayServer(deps = {}) {
         const finalArgs = [forkArgs[0], ...flagSegment, ...forkArgs.slice(1)];
         logger.info(`[${corrId}] codex_fork_session invoked (forkLast=${Boolean(forkLast)}, sessionId=${sessionId ? "set" : "unset"})`);
         try {
-            const result = await awaitJobOrDefer("codex", finalArgs, corrId, resolveIdleTimeout("codex", idleTimeoutMs), undefined, false, runtime);
+            const worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                provider: "codex",
+                workspace,
+                sessionId,
+                runtime,
+            });
+            const result = await awaitJobOrDefer("codex", finalArgs, corrId, resolveIdleTimeout("codex", idleTimeoutMs), undefined, false, runtime, undefined, undefined, undefined, undefined, undefined, worktreeResolution.cwd);
             if (isDeferredResponse(result)) {
                 return buildDeferredToolResponse(result, sessionId);
             }
@@ -3747,6 +4036,7 @@ export function createGatewayServer(deps = {}) {
             .boolean()
             .optional()
             .describe("Emit `--yolo` to auto-approve all actions. Equivalent to approvalMode 'yolo'; routed through the same approval gate. Under mcp_managed the gate still decides."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Gemini request",
@@ -3754,7 +4044,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, worktree, }) => {
+    }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, workspace, worktree, }) => {
         return handleGeminiRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -3780,6 +4070,7 @@ export function createGatewayServer(deps = {}) {
             attachments,
             skipTrust,
             yolo,
+            workspace,
             worktree,
         });
     });
@@ -3957,6 +4248,7 @@ export function createGatewayServer(deps = {}) {
             .union([z.boolean(), z.string().min(1)])
             .optional()
             .describe("Grok -w/--worktree: native CLI worktree flag (`true` → bare `--worktree`, string → named). NOT gateway slice λ `worktree`."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Grok request",
@@ -3964,7 +4256,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, worktree, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, workspace, worktree, }) => {
         return handleGrokRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -4015,6 +4307,7 @@ export function createGatewayServer(deps = {}) {
             restoreCode,
             leaderSocket,
             nativeWorktree,
+            workspace,
             worktree,
         });
     });
@@ -4097,6 +4390,7 @@ export function createGatewayServer(deps = {}) {
             .array(z.string())
             .optional()
             .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance (Vibe states this flag may be specified multiple times)."),
+        workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
         worktree: WORKTREE_SCHEMA.optional(),
     }, {
         title: "Mistral Vibe request",
@@ -4104,7 +4398,7 @@ export function createGatewayServer(deps = {}) {
         destructiveHint: true,
         idempotentHint: false,
         openWorldHint: true,
-    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
+    }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, optimizeResponse, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, workspace, worktree, }) => {
         return handleMistralRequest({ sessionManager, logger, runtime }, {
             prompt,
             promptParts,
@@ -4130,6 +4424,7 @@ export function createGatewayServer(deps = {}) {
             maxTokens,
             workingDir,
             addDir,
+            workspace,
             worktree,
         });
     });
@@ -4242,6 +4537,7 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe('Claude --tools: restrict the available built-in tool set (distinct from allowedTools permission gating). Pass [""] to disable all tools.'),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
             approvalStrategy: z
                 .enum(["legacy", "mcp_managed"])
@@ -4278,7 +4574,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, continueSession, createNewSession, allowedTools, disallowedTools, dangerouslySkipPermissions, permissionMode, agent, agents, forkSession, systemPrompt, appendSystemPrompt, maxBudgetUsd, maxTurns, effort, excludeDynamicSystemPromptSections, fallbackModel, jsonSchema, addDir, noSessionPersistence, settingSources, settings, tools, workspace, worktree, approvalStrategy, approvalPolicy, mcpServers, strictMcpConfig, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, }) => {
             if (systemPrompt !== undefined && appendSystemPrompt !== undefined) {
                 return createErrorResponse("claude", 1, "", correlationId, new Error("systemPrompt and appendSystemPrompt are mutually exclusive; use one or the other (not both)."));
             }
@@ -4349,7 +4645,14 @@ export function createGatewayServer(deps = {}) {
                 });
                 let worktreeResolution = {};
                 try {
-                    worktreeResolution = await resolveWorktreeForRequest(worktree, effectiveSessionId, runtime);
+                    worktreeResolution = await resolveWorkspaceAndWorktreeForRequest({
+                        provider: "claude",
+                        workspace,
+                        worktree,
+                        sessionId: effectiveSessionId,
+                        runtime,
+                        addDir,
+                    });
                 }
                 catch (err) {
                     return createErrorResponse("claude_request_async", 1, "", corrId, err);
@@ -4489,6 +4792,7 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe("Codex --add-dir <DIR>: additional writable workspace directories (repeat per entry). New sessions only."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Codex request (async job)",
@@ -4496,7 +4800,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, worktree, }) => {
+        }, async ({ prompt, promptParts, model, fullAuto, sandboxMode, askForApproval, useLegacyFullAutoFlag, dangerouslyBypassApprovalsAndSandbox, approvalStrategy, approvalPolicy, mcpServers, sessionId, resumeLatest, createNewSession, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, outputSchema, search, profile, configOverrides, ephemeral, images, ignoreUserConfig, ignoreRules, workingDir, addDir, workspace, worktree, }) => {
             return handleCodexRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4527,6 +4831,7 @@ export function createGatewayServer(deps = {}) {
                 ignoreRules,
                 workingDir,
                 addDir,
+                workspace,
                 worktree,
             });
         });
@@ -4598,6 +4903,7 @@ export function createGatewayServer(deps = {}) {
                 .boolean()
                 .optional()
                 .describe("Emit `--yolo` to auto-approve all actions. Equivalent to approvalMode 'yolo'; routed through the same approval gate. Under mcp_managed the gate still decides."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Gemini request (async job)",
@@ -4605,7 +4911,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, worktree, }) => {
+        }, async ({ prompt, promptParts, model, sessionId, resumeLatest, createNewSession, approvalMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, includeDirs, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, outputFormat, sandbox, policyFiles, adminPolicyFiles, attachments, skipTrust, yolo, workspace, worktree, }) => {
             return handleGeminiRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4630,6 +4936,7 @@ export function createGatewayServer(deps = {}) {
                 attachments,
                 skipTrust,
                 yolo,
+                workspace,
                 worktree,
             });
         });
@@ -4809,6 +5116,7 @@ export function createGatewayServer(deps = {}) {
                 .union([z.boolean(), z.string().min(1)])
                 .optional()
                 .describe("Grok -w/--worktree: native CLI worktree flag (`true` → bare `--worktree`, string → named). NOT gateway slice λ `worktree`."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Grok request (async job)",
@@ -4816,7 +5124,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, alwaysApprove, permissionMode, effort, reasoningEffort, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, maxTurns, workingDir, sandbox, rules, systemPromptOverride, allow, deny, compactionMode, compactionDetail, agent, bestOfN, check, disableWebSearch, todoGate, verbatim, agents, promptFile, promptJson, single, experimentalMemory, noAltScreen, noMemory, noPlan, noSubagents, oauth, restoreCode, leaderSocket, nativeWorktree, workspace, worktree, }) => {
             return handleGrokRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4866,6 +5174,7 @@ export function createGatewayServer(deps = {}) {
                 restoreCode,
                 leaderSocket,
                 nativeWorktree,
+                workspace,
                 worktree,
             });
         });
@@ -4947,6 +5256,7 @@ export function createGatewayServer(deps = {}) {
                 .array(z.string())
                 .optional()
                 .describe("Vibe --add-dir <DIR>: additional writable workspace directories. Each entry is emitted as its own --add-dir instance."),
+            workspace: WORKSPACE_ALIAS_SCHEMA.optional(),
             worktree: WORKTREE_SCHEMA.optional(),
         }, {
             title: "Mistral Vibe request (async job)",
@@ -4954,7 +5264,7 @@ export function createGatewayServer(deps = {}) {
             destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
-        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, worktree, }) => {
+        }, async ({ prompt, promptParts, model, outputFormat, sessionId, resumeLatest, createNewSession, permissionMode, approvalStrategy, approvalPolicy, mcpServers, allowedTools, disallowedTools, correlationId, optimizePrompt, idleTimeoutMs, forceRefresh, trust, maxTurns, maxPrice, maxTokens, workingDir, addDir, workspace, worktree, }) => {
             return handleMistralRequestAsync({ sessionManager, asyncJobManager, logger, runtime }, {
                 prompt,
                 promptParts,
@@ -4979,6 +5289,7 @@ export function createGatewayServer(deps = {}) {
                 maxTokens,
                 workingDir,
                 addDir,
+                workspace,
                 worktree,
             });
         });
@@ -5845,6 +6156,210 @@ async function shutdown(signal) {
 }
 process.on("SIGTERM", () => shutdown("SIGTERM"));
 process.on("SIGINT", () => shutdown("SIGINT"));
+function readMutableGatewayConfig(configPath = defaultGatewayConfigPath()) {
+    if (!existsSync(configPath))
+        return {};
+    const require = createRequire(import.meta.url);
+    const TOML = require("smol-toml");
+    return TOML.parse(readFileSync(configPath, "utf8"));
+}
+function writeMutableGatewayConfig(data, configPath = defaultGatewayConfigPath()) {
+    const require = createRequire(import.meta.url);
+    const TOML = require("smol-toml");
+    mkdirSync(dirname(configPath), { recursive: true, mode: 0o700 });
+    writeFileSync(configPath, TOML.stringify(data), { mode: 0o600 });
+    chmodSync(configPath, 0o600);
+}
+function ensureOAuthTable(config) {
+    config.http ??= {};
+    config.http.oauth ??= {};
+    const oauth = config.http.oauth;
+    oauth.enabled ??= true;
+    oauth.issuer ??= "auto";
+    oauth.require_pkce ??= true;
+    oauth.registration_policy ??= "static_clients";
+    oauth.allow_public_clients ??= false;
+    oauth.token_ttl_seconds ??= 3600;
+    oauth.clients ??= [];
+    return oauth;
+}
+function argValue(args, name) {
+    const idx = args.indexOf(name);
+    return idx >= 0 ? args[idx + 1] : undefined;
+}
+function requireArg(args, name) {
+    const value = argValue(args, name);
+    if (!value)
+        throw new Error(`Missing ${name}`);
+    return value;
+}
+function localBaseUrlForPrint() {
+    const publicUrl = process.env.LLM_GATEWAY_PUBLIC_URL;
+    if (publicUrl) {
+        try {
+            return new URL(publicUrl).origin;
+        }
+        catch {
+        }
+    }
+    return `http://${process.env.LLM_GATEWAY_HTTP_HOST ?? "127.0.0.1"}:${process.env.LLM_GATEWAY_HTTP_PORT ?? "3333"}`;
+}
+function printJsonLine(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function runOAuthCommand(args) {
+    const [scope, action] = args;
+    const config = readMutableGatewayConfig();
+    const oauth = ensureOAuthTable(config);
+    if (scope === "client") {
+        const clients = (Array.isArray(oauth.clients) ? oauth.clients : []);
+        oauth.clients = clients;
+        if (action === "add") {
+            const clientId = args[2];
+            if (!clientId)
+                throw new Error("Usage: llm-cli-gateway oauth client add <client-id> --redirect-uri <uri> [--print-once]");
+            const redirectUri = requireArg(args, "--redirect-uri");
+            const secret = generateSecret();
+            clients.push({
+                client_id: clientId,
+                client_secret_hash: hashSecret(secret),
+                allowed_redirect_uris: [redirectUri],
+                scopes: ["mcp"],
+            });
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                client_id: clientId,
+                ...(args.includes("--print-once") ? { client_secret: secret } : {}),
+                oauth: {
+                    issuer: localBaseUrlForPrint(),
+                    authorization_url: `${localBaseUrlForPrint()}/oauth/authorize`,
+                    token_url: `${localBaseUrlForPrint()}/oauth/token`,
+                },
+                note: args.includes("--print-once")
+                    ? "client_secret is shown once; it is stored only as a hash."
+                    : "client secret generated and stored only as a hash; rerun rotate --print-once if needed.",
+            });
+            return;
+        }
+        if (action === "list") {
+            printJsonLine({
+                ok: true,
+                clients: clients.map(client => ({
+                    client_id: client.client_id,
+                    redirect_uris: client.allowed_redirect_uris ?? [],
+                    secret_configured: Boolean(client.client_secret_hash),
+                })),
+            });
+            return;
+        }
+        if (action === "rotate") {
+            const clientId = args[2];
+            const client = clients.find(candidate => candidate.client_id === clientId);
+            if (!client)
+                throw new Error(`Unknown OAuth client ${clientId}`);
+            const secret = generateSecret();
+            client.client_secret_hash = hashSecret(secret);
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                client_id: clientId,
+                ...(args.includes("--print-once") ? { client_secret: secret } : {}),
+                note: "Future OAuth exchanges use the rotated secret; already-issued opaque access tokens expire by token TTL or server restart.",
+            });
+            return;
+        }
+        if (action === "revoke") {
+            const clientId = args[2];
+            oauth.clients = clients.filter(client => client.client_id !== clientId);
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                client_id: clientId,
+                note: "Future OAuth exchanges are revoked; already-issued opaque access tokens expire by token TTL or server restart.",
+            });
+            return;
+        }
+    }
+    if (scope === "shared-secret") {
+        if (action === "set" || action === "rotate") {
+            const secret = generateSecret();
+            oauth.registration_policy = "shared_secret";
+            oauth.shared_secret = {
+                enabled: true,
+                secret_hash: hashSecret(secret),
+                prompt_label: "Gateway access code",
+            };
+            writeMutableGatewayConfig(config);
+            printJsonLine({
+                ok: true,
+                shared_secret_enabled: true,
+                ...(args.includes("--print-once") ? { shared_secret: secret } : {}),
+                note: args.includes("--print-once")
+                    ? "shared_secret is shown once; it is stored only as a hash."
+                    : "shared secret generated and stored only as a hash.",
+            });
+            return;
+        }
+        if (action === "disable") {
+            oauth.shared_secret = { enabled: false, prompt_label: "Gateway access code" };
+            if (oauth.registration_policy === "shared_secret")
+                oauth.registration_policy = "static_clients";
+            writeMutableGatewayConfig(config);
+            printJsonLine({ ok: true, shared_secret_enabled: false });
+            return;
+        }
+    }
+    throw new Error("Usage: llm-cli-gateway oauth client|shared-secret ...");
+}
+function runWorkspaceCommand(args) {
+    const [action] = args;
+    if (action === "list") {
+        const registry = loadWorkspaceRegistry(logger);
+        printJsonLine({
+            ok: true,
+            default: registry.defaultAlias,
+            workspaces: registry.repos.map(describeWorkspace),
+            allowed_roots: registry.allowedRoots.map(root => ({
+                alias: root.alias,
+                path: root.path,
+                allow_create_directories: root.allowCreateDirectories,
+                allow_init_git_repos: root.allowInitGitRepos,
+            })),
+        });
+        return;
+    }
+    if (action === "create") {
+        const alias = args[1];
+        if (!alias)
+            throw new Error("Usage: llm-cli-gateway workspace create <alias> --root <root> --slug <slug> --kind folder|git [--default]");
+        const repo = createWorkspace({
+            alias,
+            rootAlias: requireArg(args, "--root"),
+            slug: requireArg(args, "--slug"),
+            kind: (argValue(args, "--kind") ?? "git"),
+            setDefault: args.includes("--default"),
+            logger,
+        });
+        printJsonLine({ ok: true, workspace: describeWorkspace(repo) });
+        return;
+    }
+    if (action === "add") {
+        const alias = args[1];
+        const repoPath = args[2];
+        if (!alias || !repoPath)
+            throw new Error("Usage: llm-cli-gateway workspace add <alias> <path> [--default]");
+        const repo = registerExistingWorkspace({
+            alias,
+            repoPath,
+            setDefault: args.includes("--default"),
+            logger,
+        });
+        printJsonLine({ ok: true, workspace: describeWorkspace(repo) });
+        return;
+    }
+    throw new Error("Usage: llm-cli-gateway workspace list|add|create ...");
+}
 async function main() {
     startWindowsBootstrapperSelfHeal();
     const args = process.argv.slice(2);
@@ -5858,6 +6373,8 @@ async function main() {
             "",
             "Usage:",
             "  llm-cli-gateway [doctor --json|contracts --json|--transport=http|--version]",
+            "  llm-cli-gateway oauth client add <id> --redirect-uri <uri> [--print-once]",
+            "  llm-cli-gateway workspace list|add|create",
             "",
             "Doctor:",
             "  doctor --json                     # environment, providers, declared contracts",
@@ -5879,6 +6396,14 @@ async function main() {
         process.stderr.write("Only doctor --json is supported in this layer.\n");
         process.exit(2);
     }
+    if (args[0] === "oauth") {
+        runOAuthCommand(args.slice(1));
+        return;
+    }
+    if (args[0] === "workspace") {
+        runWorkspaceCommand(args.slice(1));
+        return;
+    }
     if (args[0] === "contracts") {
         if (args.includes("--json")) {
             const cliArg = args.find(arg => arg.startsWith("--cli="))?.split("=")[1];