@vwork/cli 0.1.0

package/dist/functions.js

@@ -0,0 +1,237 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { stringFlag } from "./config.js";
+export async function runFunctionCommand(command, client, config, cwd) {
+    const action = command.path[1];
+    if (action === "validate") {
+        return { value: await client.request("POST", "/apps/functions/validate-source", { source_code: sourceInput(command, cwd) }) };
+    }
+    const app = await resolveApp(command, client, config);
+    const appPath = `/apps/${encodeURIComponent(String(app.id))}`;
+    if (action === "previews") {
+        return runPreviewCommand(command, client, appPath);
+    }
+    if (action === "routes") {
+        return runFunctionRouteCommand(command, client, appPath);
+    }
+    if (action === "queue-bindings") {
+        return runFunctionQueueBindingsCommand(command, client, appPath);
+    }
+    if (action === "list") {
+        const body = await client.request("GET", `${appPath}/functions`);
+        return { rows: body.functions };
+    }
+    if (action === "inspect") {
+        const name = requiredPosition(command, 0, "function name");
+        const body = await client.request("GET", `${appPath}/functions`);
+        return { value: body.functions.find((item) => item.name === name) ?? null };
+    }
+    if (action === "create") {
+        const name = requiredPosition(command, 0, "function name");
+        return {
+            value: await client.request("POST", `${appPath}/functions`, {
+                name,
+                auth_required: command.flags["no-auth"] === true ? false : true,
+                source_code: sourceInput(command, cwd),
+                ...(stringFlag(command.flags.route) ? { route_path_prefix: stringFlag(command.flags.route) } : {})
+            })
+        };
+    }
+    if (action === "deploy") {
+        const name = requiredPosition(command, 0, "function name");
+        return { value: await client.request("POST", functionPath(appPath, name, "deploy"), { source_code: sourceInput(command, cwd) }) };
+    }
+    if (action === "artifact") {
+        const name = requiredPosition(command, 0, "function name");
+        return { value: await client.request("POST", functionPath(appPath, name, "artifacts"), { source_code: sourceInput(command, cwd) }) };
+    }
+    if (action === "artifacts") {
+        const name = requiredPosition(command, 0, "function name");
+        const body = await client.request("GET", functionPath(appPath, name, "artifacts"));
+        return { rows: body.artifacts };
+    }
+    if (action === "publish" || action === "rollback") {
+        const name = requiredPosition(command, 0, "function name");
+        return {
+            value: await client.request("POST", functionPath(appPath, name, action), { artifact_id: requiredFlag(command, "artifact") })
+        };
+    }
+    if (action === "invoke") {
+        const name = requiredPosition(command, 0, "function name");
+        const body = optionalJsonObjectFlag(command, "body");
+        const artifact = stringFlag(command.flags.artifact);
+        if (artifact) {
+            return { value: await client.request("POST", `${functionPath(appPath, name, "artifacts")}/${encodeURIComponent(artifact)}/invoke`, { body }) };
+        }
+        return { value: await client.request("POST", functionPath(appPath, name, "draft-invoke"), { source_code: sourceInput(command, cwd), body }) };
+    }
+    if (action === "delete") {
+        const name = requiredPosition(command, 0, "function name");
+        return { value: await client.request("DELETE", `${appPath}/functions/${encodeURIComponent(name)}`) };
+    }
+    if (action === "metrics") {
+        const name = requiredPosition(command, 0, "function name");
+        const limit = stringFlag(command.flags.limit) ?? "50";
+        const body = await client.request("GET", `${functionPath(appPath, name, "runtime-metrics")}?limit=${encodeURIComponent(limit)}`);
+        return { rows: body.recent_invocations };
+    }
+    throw new Error(`Unknown functions command: ${action ?? ""}`);
+}
+async function runPreviewCommand(command, client, appPath) {
+    const action = command.path[2];
+    const name = requiredPosition(command, 0, "function name");
+    const basePath = functionPath(appPath, name, "previews");
+    if (action === "create") {
+        return {
+            value: await client.request("POST", basePath, {
+                artifact_id: requiredFlag(command, "artifact"),
+                ttl_seconds: parseTtlSeconds(stringFlag(command.flags.ttl) ?? "1h")
+            })
+        };
+    }
+    if (action === "list") {
+        const body = await client.request("GET", basePath);
+        return { rows: body.previews };
+    }
+    if (action === "invoke") {
+        const previewId = requiredFlag(command, "preview");
+        return { value: await client.request("POST", `${basePath}/${encodeURIComponent(previewId)}/invoke`, { body: optionalJsonObjectFlag(command, "body") }) };
+    }
+    if (action === "delete") {
+        const previewId = requiredFlag(command, "preview");
+        return { value: await client.request("DELETE", `${basePath}/${encodeURIComponent(previewId)}`) };
+    }
+    throw new Error(`Unknown functions previews command: ${action ?? ""}`);
+}
+async function runFunctionRouteCommand(command, client, appPath) {
+    const action = command.path[2];
+    const basePath = `${appPath}/function-routes`;
+    if (action === "list") {
+        const body = await client.request("GET", basePath);
+        return { rows: body.routes };
+    }
+    if (action === "add" || action === "create") {
+        const functionName = stringFlag(command.flags.function) ?? requiredPosition(command, 0, "function name");
+        const pathPrefix = stringFlag(command.flags.path) ?? stringFlag(command.flags.prefix);
+        if (!pathPrefix)
+            throw new Error("Missing --path or --prefix");
+        return {
+            value: await client.request("POST", basePath, {
+                function_name: functionName,
+                path_prefix: pathPrefix,
+                enabled: command.flags.disabled === true ? false : true
+            })
+        };
+    }
+    if (action === "enable" || action === "disable") {
+        const routeId = requiredPosition(command, 0, "route id");
+        return {
+            value: await client.request("PATCH", `${basePath}/${encodeURIComponent(routeId)}`, {
+                enabled: action === "enable"
+            })
+        };
+    }
+    if (action === "delete" || action === "remove") {
+        const routeId = requiredPosition(command, 0, "route id");
+        return { value: await client.request("DELETE", `${basePath}/${encodeURIComponent(routeId)}`) };
+    }
+    throw new Error(`Unknown functions routes command: ${action ?? ""}`);
+}
+async function runFunctionQueueBindingsCommand(command, client, appPath) {
+    const action = command.path[2];
+    const name = requiredPosition(command, 0, "function name");
+    const basePath = functionPath(appPath, name, "queue-bindings");
+    if (action === "list") {
+        const body = await client.request("GET", basePath);
+        return { rows: body.queue_bindings };
+    }
+    if (action === "replace") {
+        const queueSpecs = stringListFlag(command.flags.queue);
+        const queuesBody = await client.request("GET", `${appPath}/queues`);
+        const queuesById = new Map(queuesBody.queues.map((queue) => [queue.id, queue]));
+        return {
+            value: await client.request("PUT", basePath, {
+                queues: queueSpecs.map((spec) => queueBindingInput(spec, queuesById))
+            })
+        };
+    }
+    throw new Error(`Unknown functions queue-bindings command: ${action ?? ""}`);
+}
+async function resolveApp(command, client, config) {
+    const target = stringFlag(command.flags.app) ?? config.appId;
+    if (!target)
+        throw new Error("Missing --app");
+    return client.request("GET", `/apps/lookup/${encodeURIComponent(target)}`);
+}
+function functionPath(appPath, name, suffix) {
+    return `${appPath}/functions/${encodeURIComponent(name)}/${suffix}`;
+}
+function sourceInput(command, cwd) {
+    const inline = stringFlag(command.flags["source-code"]);
+    if (inline)
+        return inline;
+    const file = stringFlag(command.flags.bundle) ?? stringFlag(command.flags.file);
+    if (!file)
+        throw new Error("Missing --file, --bundle, or --source-code");
+    return readFileSync(resolve(cwd, file), "utf8").trim();
+}
+function optionalJsonObjectFlag(command, key) {
+    const value = stringFlag(command.flags[key]);
+    if (!value)
+        return undefined;
+    const parsed = JSON.parse(value);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`--${key} must be a JSON object`);
+    }
+    return parsed;
+}
+function stringListFlag(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "string")
+        return [value];
+    return [];
+}
+function queueBindingInput(spec, queuesById) {
+    const [queueId, mode = "producer_consumer"] = spec.split(":");
+    if (!queueId)
+        throw new Error("--queue must include a queue id");
+    if (mode !== "producer" && mode !== "consumer" && mode !== "producer_consumer") {
+        throw new Error("--queue mode must be producer, consumer, or producer_consumer");
+    }
+    const queue = queuesById.get(queueId);
+    if (!queue)
+        throw new Error(`Queue not found for --queue ${queueId}`);
+    return {
+        binding: defaultQueueBindingName(queue.name),
+        queue_id: queue.id,
+        mode
+    };
+}
+function defaultQueueBindingName(queueName) {
+    const normalized = queueName.trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (!normalized)
+        return "QUEUE";
+    return /^[A-Z_]/.test(normalized) ? normalized : `QUEUE_${normalized}`;
+}
+function parseTtlSeconds(value) {
+    const match = /^(\d+)([smhd])?$/.exec(value.trim());
+    if (!match)
+        throw new Error("--ttl must be a duration like 30m, 1h, or 2d");
+    const amount = Number(match[1]);
+    const unit = match[2] ?? "s";
+    const multiplier = unit === "d" ? 86_400 : unit === "h" ? 3_600 : unit === "m" ? 60 : 1;
+    return amount * multiplier;
+}
+function requiredFlag(command, key) {
+    const value = stringFlag(command.flags[key]);
+    if (!value)
+        throw new Error(`Missing --${key}`);
+    return value;
+}
+function requiredPosition(command, index, label) {
+    const value = command.positionals[index];
+    if (!value)
+        throw new Error(`Missing ${label}`);
+    return value;
+}

package/dist/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "node:url";
+import { runOclifCli } from "./oclif-command.js";
+export async function runCli(argv, env, cwd) {
+    await withRuntime(env, cwd, () => runOclifCli(argv));
+    return 0;
+}
+export function isDirectCliEntrypoint(moduleUrl, argvPath) {
+    if (!argvPath)
+        return false;
+    return normalizePath(fileURLToPath(moduleUrl)) === normalizePath(argvPath);
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/");
+}
+function withRuntime(env, cwd, run) {
+    const originalEnv = process.env;
+    const originalCwd = process.cwd();
+    process.env = env;
+    if (cwd !== originalCwd)
+        process.chdir(cwd);
+    return run().finally(() => {
+        process.env = originalEnv;
+        if (process.cwd() !== originalCwd)
+            process.chdir(originalCwd);
+    });
+}
+if (isDirectCliEntrypoint(import.meta.url, process.argv[1])) {
+    runCli(process.argv.slice(2), process.env, process.cwd()).then((code) => {
+        process.exitCode = code;
+    }).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/kv.js

@@ -0,0 +1,73 @@
+import { stringFlag } from "./config.js";
+export async function runKvCommand(command, client, config) {
+    const group = command.path[1];
+    const action = command.path[2];
+    const app = await resolveApp(command, client, config);
+    if (group === "namespaces" && action === "list") {
+        const body = await client.request("GET", `/apps/${encodeURIComponent(String(app.id))}/kv-namespaces`);
+        return { rows: body.kv_namespaces };
+    }
+    if (group === "namespaces" && action === "create") {
+        const body = namespaceCreateBody(command);
+        return {
+            value: await client.request("POST", `/apps/${encodeURIComponent(String(app.id))}/kv-namespaces`, body)
+        };
+    }
+    if (group === "entries" && action === "list") {
+        const namespace = requiredFlag(command, "namespace");
+        const body = await client.request("GET", withQuery(`/apps/${encodeURIComponent(String(app.id))}/kv-namespaces/${encodeURIComponent(namespace)}/entries`, {
+            prefix: stringFlag(command.flags.prefix),
+            limit: stringFlag(command.flags.limit),
+            cursor: stringFlag(command.flags.cursor)
+        }));
+        return { rows: body.keys };
+    }
+    if (group === "stats") {
+        const namespace = requiredFlag(command, "namespace");
+        const body = await client.request("GET", `/apps/${encodeURIComponent(String(app.id))}/kv-namespaces/${encodeURIComponent(namespace)}/stats`);
+        return { value: body.stats };
+    }
+    if (group === "metrics") {
+        const namespace = requiredFlag(command, "namespace");
+        const body = await client.request("GET", withQuery(`/apps/${encodeURIComponent(String(app.id))}/kv-namespaces/${encodeURIComponent(namespace)}/metrics`, {
+            range: stringFlag(command.flags.range),
+            step: stringFlag(command.flags.step),
+            granularity: stringFlag(command.flags.granularity),
+            from: stringFlag(command.flags.from),
+            to: stringFlag(command.flags.to)
+        }));
+        return { value: body.metrics };
+    }
+    throw new Error(`Unknown kv command: ${command.path.join(" ")}`);
+}
+async function resolveApp(command, client, config) {
+    const target = stringFlag(command.flags.app) ?? config.appId;
+    if (!target)
+        throw new Error("Missing --app");
+    return client.request("GET", `/apps/lookup/${encodeURIComponent(target)}`);
+}
+function namespaceCreateBody(command) {
+    const title = stringFlag(command.flags.title);
+    const name = stringFlag(command.flags.name);
+    if (!title && !name)
+        throw new Error("Missing --title");
+    return {
+        ...(title ? { title } : {}),
+        ...(name ? { name } : {})
+    };
+}
+function requiredFlag(command, key) {
+    const value = stringFlag(command.flags[key]);
+    if (!value)
+        throw new Error(`Missing --${key}`);
+    return value;
+}
+function withQuery(path, query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value)
+            searchParams.set(key, value);
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${path}?${queryString}` : path;
+}

package/dist/login.js

@@ -0,0 +1,176 @@
+import { createServer } from "node:http";
+import { PlatformClient } from "@vwork/platform-client";
+import { buildAuthorizationUrl, createPkcePair, createState } from "./auth/oidc.js";
+const DEFAULT_OIDC_CALLBACK_TIMEOUT_MS = 120_000;
+export async function runLoginCommand(input) {
+    const fetchImpl = input.fetch ?? fetch;
+    const apiUrl = input.apiUrl.replace(/\/+$/, "");
+    const response = await fetchImpl(new Request(`${apiUrl}/auth/oidc/config`, {
+        headers: { accept: "application/json" }
+    }));
+    const config = await parseJsonResponse(response);
+    if (!config.cli_redirect_uri) {
+        throw new Error("CLI OIDC redirect URI is not configured. Configure OIDC_CLI_REDIRECT_URI or use dashboard login.");
+    }
+    const pkce = createPkcePair();
+    const state = createState();
+    const authorizationUrl = buildAuthorizationUrl({
+        authorizationEndpoint: config.authorization_endpoint,
+        clientId: config.client_id,
+        redirectUri: config.cli_redirect_uri,
+        scopes: config.scopes,
+        state,
+        codeChallenge: pkce.codeChallenge
+    });
+    const createCallbackWaiter = input.createCallbackWaiter ?? createLocalOidcCallbackWaiter;
+    const callbackWaiter = await createCallbackWaiter({ redirectUri: config.cli_redirect_uri });
+    try {
+        await input.openBrowser(authorizationUrl);
+        const callback = await waitForCallbackWithTimeout(callbackWaiter.waitForCallback, input.callbackTimeoutMs ?? DEFAULT_OIDC_CALLBACK_TIMEOUT_MS);
+        if (!callback.state)
+            throw new Error("OIDC callback state is missing.");
+        if (callback.state !== state)
+            throw new Error("OIDC callback state did not match.");
+        if (callback.error) {
+            throw new Error(`OIDC login failed: ${callback.error}${callback.errorDescription ? `: ${callback.errorDescription}` : ""}`);
+        }
+        if (!callback.code)
+            throw new Error("OIDC callback code is missing.");
+        const callbackResponse = await fetchImpl(new Request(`${apiUrl}/auth/oidc/callback`, {
+            method: "POST",
+            headers: { accept: "application/json", "content-type": "application/json" },
+            body: JSON.stringify({
+                code: callback.code,
+                code_verifier: pkce.codeVerifier,
+                redirect_uri: config.cli_redirect_uri
+            })
+        }));
+        const result = await parseJsonResponse(callbackResponse);
+        if (!result.api_key)
+            throw new Error("Platform API did not return CLI credentials.");
+        await input.saveApiKey({ baseUrl: apiUrl, apiKey: result.api_key });
+        return `Logged in to ${apiUrl} as ${result.user?.email ?? result.user?.display_name ?? "unknown"}.\n`;
+    }
+    finally {
+        await callbackWaiter.close();
+    }
+}
+export async function runWhoamiCommand(input) {
+    const client = new PlatformClient({
+        apiUrl: input.apiUrl,
+        trustedUserId: null,
+        apiKey: input.credentials.api_key,
+        fetch: input.fetch
+    });
+    const me = await client.request("GET", "/auth/me");
+    const user = me.user ?? {};
+    return [
+        `API URL: ${input.apiUrl}`,
+        `User: ${user.email ?? user.display_name ?? "unknown"}`,
+        `Role: ${user.platform_role ?? "unknown"}`,
+        ""
+    ].join("\n");
+}
+async function parseJsonResponse(response) {
+    let parsed;
+    try {
+        parsed = await response.json();
+    }
+    catch (error) {
+        if (!response.ok) {
+            throw new Error(`Platform API request failed with status ${response.status}`);
+        }
+        throw error;
+    }
+    if (!response.ok) {
+        throw new Error(`Platform API request failed with status ${response.status}`);
+    }
+    return parsed;
+}
+async function waitForCallbackWithTimeout(callback, timeoutMs) {
+    let timeout = null;
+    const timeoutPromise = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            reject(new Error(`Timed out waiting for OIDC callback after ${timeoutMs}ms.`));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([callback, timeoutPromise]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+async function createLocalOidcCallbackWaiter(input) {
+    const redirectUrl = new URL(input.redirectUri);
+    const listenHost = assertLoopbackRedirectUrl(redirectUrl);
+    let settled = false;
+    let closePromise = null;
+    let resolveCallback;
+    let rejectCallback;
+    const waitForCallback = new Promise((resolve, reject) => {
+        resolveCallback = resolve;
+        rejectCallback = reject;
+    });
+    const server = createServer((request, response) => {
+        const requestUrl = new URL(request.url ?? "/", redirectUrl.origin);
+        if (request.method !== "GET" || requestUrl.pathname !== redirectUrl.pathname) {
+            response.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+            response.end("Not found");
+            return;
+        }
+        if (!settled) {
+            settled = true;
+            resolveCallback({
+                code: requestUrl.searchParams.get("code"),
+                state: requestUrl.searchParams.get("state"),
+                error: requestUrl.searchParams.get("error"),
+                errorDescription: requestUrl.searchParams.get("error_description")
+            });
+        }
+        response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        response.end("<!doctype html><title>VWork login</title><p>VWork login complete. You can close this window.</p>");
+    });
+    const port = Number(redirectUrl.port || "80");
+    await new Promise((resolve, reject) => {
+        const rejectListen = (error) => {
+            reject(error);
+        };
+        server.once("error", rejectListen);
+        server.listen(port, listenHost, () => {
+            server.off("error", rejectListen);
+            resolve();
+        });
+    });
+    server.on("error", (error) => {
+        if (!settled) {
+            settled = true;
+            rejectCallback(error);
+        }
+    });
+    return {
+        waitForCallback,
+        close: async () => {
+            if (closePromise)
+                return closePromise;
+            closePromise = new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (!error || error.code === "ERR_SERVER_NOT_RUNNING") {
+                        resolve();
+                        return;
+                    }
+                    reject(error);
+                });
+            });
+            return closePromise;
+        }
+    };
+}
+function assertLoopbackRedirectUrl(redirectUrl) {
+    const hostname = redirectUrl.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+    if (redirectUrl.protocol !== "http:" || (hostname !== "localhost" && hostname !== "127.0.0.1" && hostname !== "::1")) {
+        throw new Error("CLI OIDC redirect URI must use an http:// loopback host for the local callback listener.");
+    }
+    return hostname;
+}

package/dist/migrations.js

@@ -0,0 +1,76 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { stringFlag } from "./config.js";
+export async function runMigrationCommand(command, client, config, cwd) {
+    const action = command.path[1];
+    const app = await resolveApp(command, client, config);
+    const appPath = `/apps/${encodeURIComponent(String(app.id))}`;
+    if (action === "list") {
+        const response = await client.request("GET", `${appPath}/migration-artifacts`);
+        return { rows: response.migration_artifacts.map((artifact) => ({ version: artifact.version, schema: artifact.schema_name })) };
+    }
+    if (action === "runs") {
+        const response = await client.request("GET", `${appPath}/migrations`);
+        return { rows: response.migration_runs.map((run) => ({ version: run.version, direction: run.direction, status: run.status })) };
+    }
+    if (action === "create" || action === "up") {
+        const version = requiredPosition(command, 0, "migration version");
+        const body = {
+            version,
+            schema_name: stringFlag(command.flags.schema) ?? config.schema,
+            up_sql: sqlInput(command, "up", "up-sql", cwd),
+            down_sql: optionalSqlInput(command, "down", "down-sql", cwd)
+        };
+        return {
+            value: await client.request("POST", `${appPath}/migrations${action === "up" ? "/up" : ""}`, body)
+        };
+    }
+    if (action === "down") {
+        const version = requiredPosition(command, 0, "migration version");
+        return {
+            value: await client.request("POST", `${appPath}/migrations/down`, {
+                version,
+                reason: requiredFlag(command, "reason")
+            })
+        };
+    }
+    if (action === "delete") {
+        const version = requiredPosition(command, 0, "migration version");
+        return { value: await client.request("DELETE", `${appPath}/migration-artifacts/${encodeURIComponent(version)}`) };
+    }
+    throw new Error(`Unknown migrations command: ${action ?? ""}`);
+}
+async function resolveApp(command, client, config) {
+    const target = stringFlag(command.flags.app) ?? config.appId;
+    if (!target)
+        throw new Error("Missing --app");
+    return client.request("GET", `/apps/lookup/${encodeURIComponent(target)}`);
+}
+function sqlInput(command, fileFlag, inlineFlag, cwd) {
+    const inline = stringFlag(command.flags[inlineFlag]);
+    if (inline)
+        return inline;
+    const file = stringFlag(command.flags[fileFlag]);
+    if (!file)
+        throw new Error(`Missing --${fileFlag} or --${inlineFlag}`);
+    return readFileSync(resolve(cwd, file), "utf8").trim();
+}
+function optionalSqlInput(command, fileFlag, inlineFlag, cwd) {
+    const inline = stringFlag(command.flags[inlineFlag]);
+    if (inline)
+        return inline;
+    const file = stringFlag(command.flags[fileFlag]);
+    return file ? readFileSync(resolve(cwd, file), "utf8").trim() : null;
+}
+function requiredFlag(command, key) {
+    const value = stringFlag(command.flags[key]);
+    if (!value)
+        throw new Error(`Missing --${key}`);
+    return value;
+}
+function requiredPosition(command, index, label) {
+    const value = command.positionals[index];
+    if (!value)
+        throw new Error(`Missing ${label}`);
+    return value;
+}

package/dist/observability.js

@@ -0,0 +1,20 @@
+import { stringFlag } from "./config.js";
+export async function runObservabilityCommand(command, client) {
+    const action = command.path[1];
+    if (action === "access-logs") {
+        const query = new URLSearchParams();
+        const source = stringFlag(command.flags.source);
+        const app = stringFlag(command.flags.app);
+        const limit = stringFlag(command.flags.limit);
+        if (source)
+            query.set("source", source);
+        if (app)
+            query.set("app_id", app);
+        if (limit)
+            query.set("limit", limit);
+        const queryString = query.toString();
+        const body = await client.request("GET", `/observability/access-logs${queryString ? `?${queryString}` : ""}`);
+        return { rows: body.access_logs };
+    }
+    throw new Error(`Unknown observability command: ${action ?? ""}`);
+}