@oxagen/cli 0.3.3 → 0.5.0

package/dist/commands.test.js

@@ -6,6 +6,8 @@ vi.mock("./lib/config.js", () => ({
     readConfig: vi.fn(() => ({ token: "test-token", orgSlug: "my-org", workspaceSlug: "default" })),
     writeConfig: vi.fn(),
     clearConfig: vi.fn(),
+    getOrgId: vi.fn(() => "my-org"),
+    getWorkspaceId: vi.fn(() => "default"),
 }));
 vi.mock("./lib/api-client.js", () => ({
     apiRequest: vi.fn(),
@@ -68,6 +70,8 @@ import { documentReadCommand } from "./commands/document.read.js";
 import { formCreateCommand } from "./commands/form.create.js";
 import { formSubmitCommand } from "./commands/form.submit.js";
 import { automationCreateCommand } from "./commands/automation.create.js";
+import { automationEnableCommand } from "./commands/automation.enable.js";
+import { automationDisableCommand } from "./commands/automation.disable.js";
 import { automationTriggerCommand } from "./commands/automation.trigger.js";
 import { skillWorkspaceListCommand } from "./commands/skill.workspace.list.js";
 import { agentMemoryRecallCommand } from "./commands/agent.memory.recall.js";
@@ -97,13 +101,10 @@ import { formFillCommand } from "./commands/form.fill.js";
 import { orgMemberInviteDeclineCommand } from "./commands/org.member.invite.decline.js";
 import { organizationCreateCommand } from "./commands/organization.create.js";
 import { pluginCredentialSetSecretCommand } from "./commands/plugin.credential.set_secret.js";
-import { pluginDenylistAddCommand } from "./commands/plugin.denylist.add.js";
-import { pluginDenylistRemoveCommand } from "./commands/plugin.denylist.remove.js";
 import { pluginOrgInstallBulkCommand } from "./commands/plugin.org.install_bulk.js";
 import { pluginOrgListCommand } from "./commands/plugin.org.list.js";
 import { pluginOrgSetEnabledCommand } from "./commands/plugin.org.set_enabled.js";
 import { pluginRegistryRemoveCommand } from "./commands/plugin.registry.remove.js";
-import { pluginRegistrySyncCommand } from "./commands/plugin.registry.sync.js";
 import { pluginSettingsSetAuthAlertsCommand } from "./commands/plugin.settings.set_auth_alerts.js";
 import { pluginWorkspaceSetEnabledCommand } from "./commands/plugin.workspace.set_enabled.js";
 import { systemInstallInstructionsCommand } from "./commands/system.install.instructions.js";
@@ -118,6 +119,8 @@ const mockRequireAuth = vi.mocked(apiClient.requireAuth);
 const mockWriteConfig = vi.mocked(config.writeConfig);
 const mockClearConfig = vi.mocked(config.clearConfig);
 const mockGetToken = vi.mocked(config.getToken);
+const mockGetOrgId = vi.mocked(config.getOrgId);
+const mockGetWorkspaceId = vi.mocked(config.getWorkspaceId);
 // Helper: throw an ApiError through apiRequest mock (covers instanceof branch in catch blocks)
 function mockApiError(status, message) {
     const ApiErrorClass = apiClient.ApiError;
@@ -355,33 +358,62 @@ describe("workspace create", () => {
 // ---------------------------------------------------------------------------
 // chat send
 // ---------------------------------------------------------------------------
+// chat.send uses native fetch() directly for SSE streaming (not apiRequest).
+// Build minimal SSE response helpers here.
+function makeSseResponse(text) {
+    const line = `data: ${JSON.stringify({ type: "text", text })}\n\nevent: done\ndata: [DONE]\n\n`;
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(c) { c.enqueue(encoder.encode(line)); c.close(); },
+    });
+    return new Response(stream, {
+        status: 200,
+        headers: { "content-type": "text/event-stream" },
+    });
+}
+function makeErrorResponse(status, message) {
+    return new Response(JSON.stringify({ error: message }), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
 describe("chat send", () => {
-    it("sends message and prints response", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ content: "Hello back!" });
+    afterEach(() => { vi.restoreAllMocks(); });
+    it("sends message and streams response to stdout", async () => {
+        const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+        vi.spyOn(global, "fetch").mockResolvedValueOnce(makeSseResponse("Hello back!"));
         await chatSendCommand.parseAsync(["node", "cli", "hello"]);
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("hello"));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Hello back!"));
-        consoleSpy.mockRestore();
-    });
-    it("passes conversation id when provided", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ content: "response" });
+        const written = stdoutSpy.mock.calls.map((c) => String(c[0])).join("");
+        expect(written).toContain("Hello back!");
+        stdoutSpy.mockRestore();
+    });
+    it("passes conversationId when --conversation is provided", async () => {
+        const stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+        let capturedBody = null;
+        vi.spyOn(global, "fetch").mockImplementationOnce(async (_url, init) => {
+            capturedBody = JSON.parse(init.body);
+            return makeSseResponse("ok");
+        });
         await chatSendCommand.parseAsync(["node", "cli", "hi", "--conversation", "cnv_abc"]);
-        const calls = mockApiRequest.mock.calls;
-        const init = calls[0]?.[1];
-        const callBody = JSON.parse(init?.body);
-        expect(callBody.conversationId).toBe("cnv_abc");
-        consoleSpy.mockRestore();
+        expect(capturedBody["conversationId"]).toBe("cnv_abc");
+        stdoutSpy.mockRestore();
     });
-    it("exits 1 on API error", async () => {
+    it("exits 1 when fetch throws a network error", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("timeout"));
+        vi.spyOn(global, "fetch").mockRejectedValueOnce(new Error("ECONNREFUSED"));
         await expect(() => chatSendCommand.parseAsync(["node", "cli", "msg"])).rejects.toThrow("exit");
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
+    it("exits 1 on non-ok HTTP response", async () => {
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => { throw new Error("exit"); });
+        vi.spyOn(global, "fetch").mockResolvedValueOnce(makeErrorResponse(503, "Service unavailable"));
+        await expect(() => chatSendCommand.parseAsync(["node", "cli", "test"])).rejects.toThrow();
+        consoleSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
 });
 // ---------------------------------------------------------------------------
 // conversation commands
@@ -637,7 +669,7 @@ describe("agent mcp list", () => {
             servers: [{ id: "mcp1", name: "claude", status: "active" }],
         });
         await agentMcpListCommand.parseAsync(["node", "cli"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/agent/mcp/list?", expect.objectContaining({ method: "GET" }));
+        expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("/agent/mcp/list"), expect.objectContaining({ method: "GET" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("MCP Servers"));
         consoleSpy.mockRestore();
     });
@@ -652,7 +684,7 @@ describe("agent skill list", () => {
             skills: [{ id: "skill1", name: "memory", description: "Memory management" }],
         });
         await agentSkillListCommand.parseAsync(["node", "cli"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/agent/skill/list?", expect.objectContaining({ method: "GET" }));
+        expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("/agent/skill/list"), expect.objectContaining({ method: "GET" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Agent Skills"));
         consoleSpy.mockRestore();
     });
@@ -667,7 +699,7 @@ describe("agent tool list", () => {
             tools: [{ id: "tool1", name: "search", description: "Search capability" }],
         });
         await agentToolListCommand.parseAsync(["node", "cli"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/agent/tool/list?", expect.objectContaining({ method: "GET" }));
+        expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("/agent/tool/list"), expect.objectContaining({ method: "GET" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Agent Tools"));
         consoleSpy.mockRestore();
     });
@@ -698,7 +730,7 @@ describe("billing subscription read", () => {
             subscription: { id: "sub1", plan: "scale", status: "active" },
         });
         await billingSubscriptionReadCommand.parseAsync(["node", "cli"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/billing/subscription/read?", expect.objectContaining({ method: "GET" }));
+        expect(mockApiRequest).toHaveBeenCalledWith(expect.stringContaining("/billing/subscription/read"), expect.objectContaining({ method: "GET" }));
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Current Subscription"));
         consoleSpy.mockRestore();
     });
@@ -974,14 +1006,109 @@ describe("automation list", () => {
     });
 });
 describe("automation create", () => {
-    it("creates automation", async () => {
+    it("creates automation with the contract payload shape", async () => {
         const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ id: "auto1", name: "My Automation" });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_1",
+            playbook_id: "plb_1",
+            name: "My Automation",
+            status: "inactive",
+            triggerType: "api",
+            enabled: false,
+        });
         await automationCreateCommand.parseAsync(["node", "cli", "-n", "My Automation"]);
         expect(mockApiRequest).toHaveBeenCalledWith("/automation/create", expect.objectContaining({ method: "POST" }));
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toMatchObject({
+            name: "My Automation",
+            triggerType: "api",
+            triggerConfig: {},
+            steps: [],
+            enabled: false,
+        });
         expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Automation created"));
         consoleSpy.mockRestore();
     });
+    it("builds event triggerConfig from --entity-type/--event-type/--conditions and passes --enabled", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_2",
+            playbook_id: "plb_2",
+            name: "Watcher",
+            status: "active",
+            triggerType: "event",
+            enabled: true,
+        });
+        await automationCreateCommand.parseAsync([
+            "node", "cli",
+            "-n", "Watcher",
+            "--trigger-type", "event",
+            "--entity-type", "Contact",
+            "--event-type", "node.updated",
+            "--conditions", '[{"property":"status","toValue":"customer","operator":"eq"}]',
+            "--enabled",
+        ]);
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toMatchObject({
+            name: "Watcher",
+            triggerType: "event",
+            triggerConfig: {
+                entityType: "Contact",
+                eventType: "node.updated",
+                propertyConditions: [{ property: "status", toValue: "customer", operator: "eq" }],
+            },
+            enabled: true,
+        });
+        consoleSpy.mockRestore();
+    });
+    it("builds schedule triggerConfig from --cron/--timezone", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({
+            automation_id: "plt_3",
+            playbook_id: "plb_3",
+            name: "Report",
+            status: "inactive",
+            triggerType: "schedule",
+            enabled: false,
+        });
+        await automationCreateCommand.parseAsync([
+            "node", "cli",
+            "-n", "Report",
+            "--trigger-type", "schedule",
+            "--cron", "0 9 * * 1",
+            "--timezone", "America/New_York",
+        ]);
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toMatchObject({
+            triggerType: "schedule",
+            triggerConfig: { cronExpression: "0 9 * * 1", timezone: "America/New_York" },
+        });
+        consoleSpy.mockRestore();
+    });
+});
+describe("automation enable", () => {
+    it("enables automation", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({ automation_id: "plt_1", enabled: true, status: "active" });
+        await automationEnableCommand.parseAsync(["node", "cli", "plt_1"]);
+        expect(mockApiRequest).toHaveBeenCalledWith("/automation/enable", expect.objectContaining({ method: "POST" }));
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toEqual({ automation_id: "plt_1" });
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Automation enabled"));
+        consoleSpy.mockRestore();
+    });
+});
+describe("automation disable", () => {
+    it("disables automation", async () => {
+        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+        mockApiRequest.mockResolvedValueOnce({ automation_id: "plt_1", enabled: false, status: "paused" });
+        await automationDisableCommand.parseAsync(["node", "cli", "plt_1"]);
+        expect(mockApiRequest).toHaveBeenCalledWith("/automation/disable", expect.objectContaining({ method: "POST" }));
+        const body = JSON.parse((mockApiRequest.mock.calls[0]?.[1]).body);
+        expect(body).toEqual({ automation_id: "plt_1" });
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Automation disabled"));
+        consoleSpy.mockRestore();
+    });
 });
 describe("automation trigger", () => {
     it("triggers automation", async () => {
@@ -1610,45 +1737,6 @@ describe("plugin credential set_secret", () => {
     });
 });
 // ---------------------------------------------------------------------------
-// plugin denylist
-// ---------------------------------------------------------------------------
-describe("plugin denylist add", () => {
-    it("adds a server to the denylist", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginDenylistAddCommand.parseAsync(["node", "cli", "-s", "bad-server"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/plugin/denylist/add", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("bad-server"));
-        consoleSpy.mockRestore();
-    });
-    it("handles denylist add failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Server not found"));
-        await expect(pluginDenylistAddCommand.parseAsync(["node", "cli", "-s", "srv"])).rejects.toThrow();
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-describe("plugin denylist remove", () => {
-    it("removes a server from the denylist", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ ok: true });
-        await pluginDenylistRemoveCommand.parseAsync(["node", "cli", "-s", "bad-server"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/plugin/denylist/remove", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("bad-server"));
-        consoleSpy.mockRestore();
-    });
-    it("handles denylist remove failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Entry not found"));
-        await expect(pluginDenylistRemoveCommand.parseAsync(["node", "cli", "-s", "srv"])).rejects.toThrow();
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-// ---------------------------------------------------------------------------
 // plugin org install bulk
 // ---------------------------------------------------------------------------
 describe("plugin org install bulk", () => {
@@ -1760,35 +1848,6 @@ describe("plugin registry remove", () => {
     });
 });
 // ---------------------------------------------------------------------------
-// plugin registry sync
-// ---------------------------------------------------------------------------
-describe("plugin registry sync", () => {
-    it("triggers a registry sync", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ accepted: true });
-        await pluginRegistrySyncCommand.parseAsync(["node", "cli", "-r", "reg1"]);
-        expect(mockApiRequest).toHaveBeenCalledWith("/plugin/registry/sync", expect.objectContaining({ method: "POST" }));
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Sync accepted"));
-        consoleSpy.mockRestore();
-    });
-    it("reports sync not accepted", async () => {
-        const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
-        mockApiRequest.mockResolvedValueOnce({ accepted: false });
-        await pluginRegistrySyncCommand.parseAsync(["node", "cli", "-r", "reg1"]);
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("not accepted"));
-        consoleSpy.mockRestore();
-    });
-    it("handles sync failure", async () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("process.exit"); });
-        mockApiRequest.mockRejectedValueOnce(new Error("Registry not found"));
-        await expect(pluginRegistrySyncCommand.parseAsync(["node", "cli", "-r", "reg1"])).rejects.toThrow();
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
-        consoleSpy.mockRestore();
-        exitSpy.mockRestore();
-    });
-});
-// ---------------------------------------------------------------------------
 // plugin settings set_auth_alerts
 // ---------------------------------------------------------------------------
 describe("plugin settings set_auth_alerts", () => {
@@ -2020,6 +2079,24 @@ describe("branch coverage: ApiError error paths", () => {
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
+    it("automation enable returns ApiError message", async () => {
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        mockApiError(404, "Automation not found");
+        await expect(automationEnableCommand.parseAsync(["node", "cli", "plt_missing"])).rejects.toThrow();
+        expect(consoleSpy).toHaveBeenCalledWith("Error: Automation not found");
+        consoleSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+    it("automation disable returns ApiError message", async () => {
+        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
+        const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
+        mockApiError(404, "Automation not found");
+        await expect(automationDisableCommand.parseAsync(["node", "cli", "plt_missing"])).rejects.toThrow();
+        expect(consoleSpy).toHaveBeenCalledWith("Error: Automation not found");
+        consoleSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
     it("automation trigger returns ApiError message", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
@@ -2187,9 +2264,12 @@ describe("branch coverage: empty/optional data branches", () => {
     it("chat send ApiError path", async () => {
         const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => { });
         const exitSpy = vi.spyOn(process, "exit").mockImplementation((_code) => { throw new Error("exit"); });
-        mockApiError(503, "Service unavailable");
+        // chat.send uses native fetch (not apiRequest); mock fetch directly.
+        vi.spyOn(global, "fetch").mockResolvedValueOnce(new Response(JSON.stringify({ error: "Service unavailable" }), {
+            status: 503,
+            headers: { "content-type": "application/json" },
+        }));
         await expect(chatSendCommand.parseAsync(["node", "cli", "test"])).rejects.toThrow();
-        expect(consoleSpy).toHaveBeenCalledWith("Error: Service unavailable");
         consoleSpy.mockRestore();
         exitSpy.mockRestore();
     });
@@ -2218,4 +2298,147 @@ describe("branch coverage: empty/optional data branches", () => {
         exitSpy.mockRestore();
     });
 });
+describe("Environment Variable Defaults", () => {
+    beforeEach(() => {
+        mockGetOrgId.mockReturnValue("default-org");
+        mockGetWorkspaceId.mockReturnValue("default-workspace");
+        mockGetToken.mockReturnValue("default-token");
+    });
+    afterEach(() => {
+        delete process.env.OXAGEN_ORG_ID;
+        delete process.env.OXAGEN_WORKSPACE_ID;
+        delete process.env.OXAGEN_API_TOKEN;
+        vi.clearAllMocks();
+    });
+    describe("OXAGEN_ORG_ID environment variable", () => {
+        it("org member list uses OXAGEN_ORG_ID env var when no --org flag provided", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockGetOrgId.mockReturnValue("env-org-123");
+            mockApiRequest.mockResolvedValueOnce({ members: [] });
+            await orgMemberAddCommand.parseAsync(["node", "cli", "user@example.com", "--role", "admin"]);
+            expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining("env-org-123"),
+            }));
+            consoleSpy.mockRestore();
+        });
+        it("org member list uses command-line --org flag to override OXAGEN_ORG_ID env var", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockGetOrgId.mockReturnValue("env-org-123");
+            mockApiRequest.mockResolvedValueOnce({ members: [] });
+            await orgMemberAddCommand.parseAsync(["node", "cli", "user@example.com", "--role", "admin", "--org", "cli-org-456"]);
+            expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining("cli-org-456"),
+            }));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("OXAGEN_WORKSPACE_ID environment variable", () => {
+        afterEach(() => {
+            mockApiRequest.mockClear();
+        });
+        it("workspace member list uses env var default when no --workspace flag", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockGetWorkspaceId.mockReturnValue("env-workspace-789");
+            mockApiRequest.mockResolvedValueOnce([]);
+            await workspaceMemberListCommand.parseAsync(["node", "cli"]);
+            const calls = mockApiRequest.mock.calls;
+            expect(calls.length).toBeGreaterThan(0);
+            expect(calls[0]?.[0]).toContain("workspace_id=env-workspace-789");
+            consoleSpy.mockRestore();
+        });
+        it("workspace member list uses explicit flag to override env var", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockGetWorkspaceId.mockReturnValue("env-workspace-789");
+            mockApiRequest.mockResolvedValueOnce([]);
+            await workspaceMemberListCommand.parseAsync(["node", "cli", "-w", "cli-workspace-xyz"]);
+            const calls = mockApiRequest.mock.calls;
+            expect(calls.length).toBeGreaterThan(0);
+            expect(calls[0]?.[0]).toContain("workspace_id=cli-workspace-xyz");
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("OXAGEN_API_TOKEN environment variable", () => {
+        it("uses OXAGEN_API_TOKEN for Bearer token in Authorization header", async () => {
+            mockGetToken.mockReturnValue("sk-token-from-env");
+            mockApiRequest.mockResolvedValueOnce({ key: "key123" });
+            await apiKeyCreateCommand.parseAsync(["node", "cli", "mykey"]);
+            expect(mockApiRequest).toHaveBeenCalled();
+        });
+    });
+    describe("Precedence: env vars > command-line args (fallback pattern)", () => {
+        it("agent mcp register: workspace_id uses command-line --workspace when provided", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockGetWorkspaceId.mockReturnValue("env-workspace-999");
+            mockApiRequest.mockResolvedValueOnce({
+                mcpServerId: "mcp-123",
+                healthStatus: "healthy",
+                discoveredTools: ["tool1"],
+            });
+            await agentMcpRegisterCommand.parseAsync([
+                "node", "cli", "register",
+                "-n", "my-mcp",
+                "-u", "http://localhost:9000",
+                "-t", "streamable-http",
+                "-w", "explicit-workspace-888"
+            ]);
+            expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining("explicit-workspace-888"),
+            }));
+            consoleSpy.mockRestore();
+        });
+        it("agent mcp register: org_id uses getOrgId fallback when no --org flag provided", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockGetOrgId.mockReturnValue("fallback-org-111");
+            mockGetWorkspaceId.mockReturnValue("any-workspace");
+            mockApiRequest.mockResolvedValueOnce({
+                mcpServerId: "mcp-456",
+                healthStatus: "healthy",
+                discoveredTools: [],
+            });
+            await agentMcpRegisterCommand.parseAsync([
+                "node", "cli", "register",
+                "-n", "my-mcp",
+                "-u", "http://localhost:9000",
+                "-t", "streamable-http"
+            ]);
+            expect(mockApiRequest).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining("fallback-org-111"),
+            }));
+            consoleSpy.mockRestore();
+        });
+    });
+    describe("Multiple commands with env var defaults", () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+            mockGetWorkspaceId.mockReturnValue("env-ws-default");
+            // Commander retains option values between parseAsync calls; reset to avoid cross-test pollution
+            workspaceMemberListCommand.setOptionValue("workspace", undefined);
+        });
+        it("workspace member list uses OXAGEN_WORKSPACE_ID as default when no --workspace flag", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockApiRequest.mockResolvedValueOnce([
+                { id: "user1", email: "user@test.com", role: "member", joined_at: "2024-01-01" }
+            ]);
+            await workspaceMemberListCommand.parseAsync(["node", "cli"]);
+            const calls = mockApiRequest.mock.calls;
+            expect(calls.length).toBeGreaterThan(0);
+            expect(calls[0]?.[0]).toContain("workspace_id=env-ws-default");
+            consoleSpy.mockRestore();
+        });
+        it("workspace member list uses explicit --workspace to override OXAGEN_WORKSPACE_ID", async () => {
+            const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => { });
+            mockApiRequest.mockResolvedValueOnce([
+                { id: "user1", email: "user@test.com", role: "member", joined_at: "2024-01-01" }
+            ]);
+            await workspaceMemberListCommand.parseAsync([
+                "node", "cli",
+                "-w", "explicit-ws"
+            ]);
+            const calls = mockApiRequest.mock.calls;
+            expect(calls.length).toBeGreaterThan(0);
+            expect(calls[0]?.[0]).toContain("workspace_id=explicit-ws");
+            consoleSpy.mockRestore();
+        });
+    });
+});
 //# sourceMappingURL=commands.test.js.map