@vwork/cli 0.1.0

package/dist/apps.js

@@ -0,0 +1,53 @@
+import { stringFlag } from "./config.js";
+export async function runAppCommand(command, client) {
+    const action = command.path[1];
+    if (action === "list") {
+        const body = await client.request("GET", "/apps");
+        return { rows: body.apps.map((app) => ({ id: app.id, slug: app.slug, host: app.api_host })) };
+    }
+    if (action === "inspect") {
+        const target = requiredPosition(command, 0, "app id or slug");
+        return { value: await client.request("GET", `/apps/lookup/${encodeURIComponent(target)}`) };
+    }
+    if (action === "create") {
+        const host = stringFlag(command.flags.host);
+        const body = {
+            name: requiredFlag(command, "name"),
+            slug: requiredFlag(command, "slug"),
+            ...(host ? { api_host: host } : {}),
+            data_source_id: requiredFlag(command, "data-source"),
+            schema_name: stringFlag(command.flags.schema) ?? "public",
+            isolation_mode: stringFlag(command.flags.isolation) ?? "shared_schema"
+        };
+        return { value: await client.request("POST", "/apps", body) };
+    }
+    if (action === "delete") {
+        const target = requiredPosition(command, 0, "app id or slug");
+        const app = await client.request("GET", `/apps/lookup/${encodeURIComponent(target)}`);
+        return { value: await client.request("DELETE", `/apps/${encodeURIComponent(String(app.id))}`) };
+    }
+    if (action === "bind-data-source") {
+        const target = requiredPosition(command, 0, "app id or slug");
+        const app = await client.request("GET", `/apps/lookup/${encodeURIComponent(target)}`);
+        return {
+            value: await client.request("POST", `/apps/${encodeURIComponent(String(app.id))}/bind-data-source`, {
+                data_source_id: requiredFlag(command, "data-source"),
+                schema_name: stringFlag(command.flags.schema) ?? "public",
+                isolation_mode: stringFlag(command.flags.isolation) ?? "shared_schema"
+            })
+        };
+    }
+    throw new Error(`Unknown apps command: ${action ?? ""}`);
+}
+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/auth/oidc.js

@@ -0,0 +1,23 @@
+import { createHash, randomBytes } from "node:crypto";
+export function createPkcePair() {
+    const codeVerifier = base64Url(randomBytes(32));
+    const codeChallenge = base64Url(createHash("sha256").update(codeVerifier).digest());
+    return { codeVerifier, codeChallenge };
+}
+export function createState() {
+    return base64Url(randomBytes(24));
+}
+export function buildAuthorizationUrl(input) {
+    const url = new URL(input.authorizationEndpoint);
+    url.searchParams.set("client_id", input.clientId);
+    url.searchParams.set("redirect_uri", input.redirectUri);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("scope", input.scopes.join(" "));
+    url.searchParams.set("state", input.state);
+    url.searchParams.set("code_challenge", input.codeChallenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    return url.toString();
+}
+function base64Url(bytes) {
+    return Buffer.from(bytes).toString("base64url");
+}

package/dist/auth/store.js

@@ -0,0 +1,63 @@
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function resolveCredentialPath(env, home) {
+    if (env.VWORK_HOME)
+        return join(env.VWORK_HOME, "credentials.json");
+    return join(home, ".vwork", "credentials.json");
+}
+export function resolveCompatibilityCredentialPath(home) {
+    return join(home, ".memhub", "credentials.json");
+}
+export class FileCredentialStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async saveApiKey(input) {
+        const credentials = {
+            base_url: input.baseUrl,
+            auth_mode: "api_key",
+            api_key: input.apiKey
+        };
+        const path = join(this.root, "credentials.json");
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
+        await chmod(path, 0o600);
+    }
+    async loadCredentials() {
+        const path = join(this.root, "credentials.json");
+        if (!existsSync(path))
+            return null;
+        return parseCredentials(await readFile(path, "utf8"));
+    }
+}
+export async function loadDefaultCredentials(env = process.env, home = homedir()) {
+    const path = resolveCredentialPath(env, home);
+    if (existsSync(path))
+        return parseCredentials(await readFile(path, "utf8"));
+    if (env.VWORK_HOME)
+        return null;
+    const compatibilityPath = resolveCompatibilityCredentialPath(home);
+    if (existsSync(compatibilityPath))
+        return parseCredentials(await readFile(compatibilityPath, "utf8"));
+    return null;
+}
+function parseCredentials(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Invalid VWork credentials file.");
+    }
+    const credentials = parsed;
+    if (typeof credentials.base_url !== "string" ||
+        credentials.auth_mode !== "api_key" ||
+        typeof credentials.api_key !== "string") {
+        throw new Error("Invalid VWork credentials file.");
+    }
+    return {
+        base_url: credentials.base_url,
+        auth_mode: "api_key",
+        api_key: credentials.api_key
+    };
+}

package/dist/client.js

@@ -0,0 +1,45 @@
+export class PlatformApiError extends Error {
+    code;
+    status;
+    requestId;
+    constructor(input) {
+        super(input.message);
+        this.code = input.code;
+        this.status = input.status;
+        this.requestId = input.requestId;
+    }
+}
+export class PlatformClient {
+    apiUrl;
+    trustedUserId;
+    fetchImpl;
+    constructor(input) {
+        this.apiUrl = input.apiUrl.replace(/\/+$/, "");
+        this.trustedUserId = input.trustedUserId;
+        this.fetchImpl = input.fetch ?? fetch;
+    }
+    async request(method, path, body) {
+        const headers = new Headers({ accept: "application/json" });
+        if (body !== undefined)
+            headers.set("content-type", "application/json");
+        if (this.trustedUserId)
+            headers.set("x-vwork-cli-user-id", this.trustedUserId);
+        const response = await this.fetchImpl(new Request(`${this.apiUrl}${path}`, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body)
+        }));
+        const text = await response.text();
+        const parsed = text ? JSON.parse(text) : null;
+        if (!response.ok) {
+            const error = parsed && typeof parsed === "object" && "error" in parsed ? parsed.error : {};
+            throw new PlatformApiError({
+                code: error.code ?? "PLATFORM_API_ERROR",
+                message: error.message ?? `Platform API request failed with status ${response.status}`,
+                status: response.status,
+                requestId: response.headers.get("x-request-id")
+            });
+        }
+        return parsed;
+    }
+}

package/dist/codegen.js

@@ -0,0 +1,140 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { stringFlag } from "./config.js";
+export async function runCodegenCommand(command, client, config) {
+    const group = command.path[1];
+    const action = command.path[2];
+    if (group === "skill" && action === "install-curl") {
+        const baseUrl = stringFlag(command.flags["base-url"]) ?? "https://raw.githubusercontent.com/vwork/vwork/main";
+        const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+        return {
+            value: {
+                skill: "vwork-codegen",
+                install_command: `curl -fsSL ${normalizedBaseUrl}/scripts/install-vwork-codegen-skill.sh | bash`,
+                install_path: "${CODEX_HOME:-$HOME/.codex}/skills/vwork-codegen"
+            }
+        };
+    }
+    if (group === "mcp" && action === "config-snippet") {
+        return { value: mcpConfigSnippet(command, config) };
+    }
+    const app = await resolveApp(command, client, config);
+    const appPath = `/apps/${encodeURIComponent(String(app.id))}`;
+    if (group === "mobile" && action === "from-schema") {
+        const tableNames = arrayFlag(command.flags.table);
+        return {
+            value: await client.request("POST", `${appPath}/generate-mobile-crud-from-schema`, {
+                schema_name: stringFlag(command.flags.schema) ?? config.schema,
+                ...(tableNames.length > 0 ? { table_names: tableNames } : {}),
+                ...(stringFlag(command.flags.prompt) ? { prompt: stringFlag(command.flags.prompt) } : {})
+            })
+        };
+    }
+    if (group === "function" && action === "generate") {
+        const functionName = requiredFlag(command, "function");
+        const prompt = requiredFlag(command, "prompt");
+        const bindingNames = arrayFlag(command.flags.binding);
+        const sourceCode = stringFlag(command.flags["source-code"]);
+        const draftInvoke = draftInvokeInput(command);
+        return {
+            value: await client.request("POST", `${appPath}/functions/${encodeURIComponent(functionName)}/codegen`, {
+                prompt,
+                auth_required: command.flags["no-auth"] === true ? false : true,
+                ...(bindingNames.length > 0 ? { binding_names: bindingNames } : {}),
+                ...(sourceCode ? { source_code: sourceCode } : {}),
+                ...(command.flags.repair === true ? { repair: { enabled: true, max_attempts: 2 } } : {}),
+                ...(draftInvoke ? { draft_invoke: draftInvoke } : {})
+            })
+        };
+    }
+    if (group === "runs" && action === "list") {
+        const body = await client.request("GET", `${appPath}/code-generations`);
+        return { rows: body.code_generations };
+    }
+    if (group === "runs" && action === "download") {
+        const runId = requiredFlag(command, "run");
+        const out = requiredFlag(command, "out");
+        const bundle = await client.requestBytes("GET", `${appPath}/code-generations/${encodeURIComponent(runId)}/bundle`);
+        const bytes = extractBytes(bundle);
+        const path = resolve(process.cwd(), out);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, bytes);
+        return { value: { path, bytes: bytes.length } };
+    }
+    if (group === "runs" && action === "verify") {
+        const runId = requiredFlag(command, "run");
+        const body = await client.request("GET", `${appPath}/code-generations`);
+        const exists = body.code_generations.some((run) => String(run.id) === runId);
+        if (!exists)
+            throw new Error(`Missing code generation run: ${runId}`);
+        const bundle = await client.requestBytes("GET", `${appPath}/code-generations/${encodeURIComponent(runId)}/bundle`);
+        const bytes = extractBytes(bundle);
+        return { value: { run_id: runId, bundle_downloadable: true, bytes: bytes.length } };
+    }
+    throw new Error(`Unknown codegen 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 arrayFlag(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "string")
+        return [value];
+    return [];
+}
+function requiredFlag(command, key) {
+    const value = stringFlag(command.flags[key]);
+    if (!value)
+        throw new Error(`Missing --${key}`);
+    return value;
+}
+function draftInvokeInput(command) {
+    const body = optionalJsonObjectFlag(command, "draft-invoke-body");
+    const bindings = optionalJsonObjectFlag(command, "draft-invoke-bindings");
+    if (!body && !bindings)
+        return undefined;
+    return {
+        enabled: true,
+        ...(body ? { body } : {}),
+        ...(bindings ? { bindings } : {})
+    };
+}
+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 mcpConfigSnippet(command, config) {
+    const workspace = stringFlag(command.flags.workspace) ?? process.cwd();
+    const appId = stringFlag(command.flags.app) ?? config.appId;
+    return {
+        server: "mcp-vwork",
+        install_hint: "pnpm --filter @vwork/mcp-vwork build",
+        codex_config: {
+            mcp_servers: {
+                vwork: {
+                    command: "pnpm",
+                    args: ["--dir", workspace, "--filter", "@vwork/mcp-vwork", "dev"],
+                    env: {
+                        VWORK_API_URL: stringFlag(command.flags["api-url"]) ?? config.apiUrl,
+                        VWORK_MCP_WRITE_MODE: "codegen",
+                        ...(appId ? { VWORK_APP_ID: appId } : {}),
+                        VWORK_SCHEMA: stringFlag(command.flags.schema) ?? config.schema
+                    }
+                }
+            }
+        }
+    };
+}
+function extractBytes(response) {
+    return response instanceof Uint8Array ? response : response.bytes;
+}

package/dist/command.js

@@ -0,0 +1,70 @@
+const COMMAND_ROOTS = new Set(["apps", "db", "migrations", "functions", "codegen", "secrets", "kv", "queues", "runtime", "observability"]);
+const BOOLEAN_FLAGS = new Set(["yes", "verbose", "help", "no-auth", "repair"]);
+export function parseCommand(argv) {
+    const path = [];
+    const positionals = [];
+    const flags = {};
+    let commandStarted = false;
+    let commandFlagSeen = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index] ?? "";
+        if (token === "--") {
+            positionals.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token.startsWith("--")) {
+            if (commandStarted)
+                commandFlagSeen = true;
+            const raw = token.slice(2);
+            const eqIndex = raw.indexOf("=");
+            const key = eqIndex >= 0 ? raw.slice(0, eqIndex) : raw;
+            const inlineValue = eqIndex >= 0 ? raw.slice(eqIndex + 1) : undefined;
+            const next = argv[index + 1];
+            const value = inlineValue ?? (BOOLEAN_FLAGS.has(key) ? true : next && !next.startsWith("--") ? next : true);
+            if (inlineValue === undefined && value !== true)
+                index += 1;
+            appendFlag(flags, key, value);
+            continue;
+        }
+        if (!commandStarted) {
+            if (COMMAND_ROOTS.has(token)) {
+                commandStarted = true;
+                path.push(token);
+            }
+            else {
+                positionals.push(token);
+            }
+            continue;
+        }
+        if (!commandFlagSeen && path.length < maxPathLength(path)) {
+            path.push(token);
+        }
+        else {
+            positionals.push(token);
+        }
+    }
+    return { path, positionals, flags };
+}
+function maxPathLength(path) {
+    if (path[0] === "db")
+        return 3;
+    if (path[0] === "codegen")
+        return 3;
+    if (path[0] === "kv")
+        return 3;
+    if (path[0] === "functions" && path[1] === "previews")
+        return 3;
+    if (path[0] === "functions" && path[1] === "routes")
+        return 3;
+    if (path[0] === "functions" && path[1] === "queue-bindings")
+        return 3;
+    return 2;
+}
+function appendFlag(target, key, value) {
+    const existing = target[key];
+    if (existing === undefined) {
+        target[key] = value;
+        return;
+    }
+    target[key] = Array.isArray(existing) ? [...existing, String(value)] : [String(existing), String(value)];
+}

package/dist/config.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseCommand } from "./command.js";
+export const DEFAULT_CLI_TRUSTED_USER_ID = "user_cli_dev";
+export function resolveCliConfig(argv, env, cwd) {
+    const command = parseCommand(argv);
+    return resolveCliConfigFromFlags(command.flags, env, cwd);
+}
+export function resolveCliConfigFromFlags(flags, env, cwd, defaultApiUrl = "http://127.0.0.1:8787") {
+    const project = readProjectConfig(cwd);
+    const apiUrl = stringFlag(flags["api-url"]) ?? env.VWORK_API_URL ?? project.apiUrl ?? defaultApiUrl;
+    const appId = stringFlag(flags.app) ?? env.VWORK_APP_ID ?? project.appId ?? null;
+    const schema = stringFlag(flags.schema) ?? env.VWORK_SCHEMA ?? project.schema ?? "public";
+    const output = outputFormat(stringFlag(flags.format) ?? env.VWORK_OUTPUT ?? project.output ?? "table");
+    const trustedUserId = env.VWORK_CLI_TRUSTED_USER_ID ?? project.trustedUserId ?? DEFAULT_CLI_TRUSTED_USER_ID;
+    return { apiUrl: apiUrl.replace(/\/+$/, ""), appId, schema, output, trustedUserId };
+}
+function readProjectConfig(cwd) {
+    const path = join(cwd, ".vwork", "config.json");
+    if (!existsSync(path))
+        return {};
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+export function stringFlag(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.at(-1);
+    return undefined;
+}
+function outputFormat(value) {
+    if (value === "json" || value === "table")
+        return value;
+    throw new Error(`Unsupported output format: ${value}`);
+}

package/dist/db.js

@@ -0,0 +1,124 @@
+import { stringFlag } from "./config.js";
+export async function runDbCommand(command, client, config) {
+    const group = command.path[1];
+    const action = command.path[2];
+    const app = await resolveApp(command, client, config);
+    const schema = stringFlag(command.flags.schema) ?? config.schema;
+    if (group === "tables" && action === "list") {
+        const response = await client.request("GET", withQuery(`/apps/${encodeURIComponent(String(app.id))}/database/tables`, { schema }));
+        return { rows: response.tables.map((table) => ({ name: table.name, columns: table.columns?.length ?? 0 })) };
+    }
+    if (group === "sql" && (action === "exec" || action === "preview")) {
+        const sql = requiredFlag(command, "sql");
+        const response = await client.request("POST", `/apps/${encodeURIComponent(String(app.id))}/sql/${action === "preview" ? "preview" : "execute"}`, { schema_name: schema, sql });
+        return { rows: response.rows ?? [] };
+    }
+    if (group === "rows") {
+        return runRowCommand(command, client, app, schema);
+    }
+    throw new Error(`Unknown db command: ${command.path.join(" ")}`);
+}
+async function runRowCommand(command, client, app, schema) {
+    const action = command.path[2];
+    const table = requiredPosition(command, 0, "table name");
+    const basePath = `/apps/${encodeURIComponent(String(app.id))}/tables/${encodeURIComponent(table)}/rows`;
+    if (action === "select") {
+        const response = await client.request("GET", withQuery(basePath, rowSelectQuery(command, schema)));
+        return { rows: response.rows ?? [] };
+    }
+    if (action === "insert") {
+        const response = await client.request("POST", basePath, { schema_name: schema, row: jsonObjectFlag(command, "data") });
+        return { rows: response.rows ?? [] };
+    }
+    if (action === "update") {
+        const response = await client.request("PATCH", basePath, {
+            schema_name: schema,
+            primary_key: primaryKeyFlag(command),
+            patch: jsonObjectFlag(command, "data")
+        });
+        return { rows: response.rows ?? [] };
+    }
+    if (action === "delete") {
+        const response = await client.request("DELETE", basePath, {
+            schema_name: schema,
+            primary_key: primaryKeyFlag(command)
+        });
+        return { rows: response.rows ?? [] };
+    }
+    throw new Error(`Unknown db rows 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 rowSelectQuery(command, schema) {
+    const query = { schema };
+    const limit = stringFlag(command.flags.limit);
+    const offset = stringFlag(command.flags.offset);
+    const order = stringFlag(command.flags.order);
+    if (limit)
+        query.limit = limit;
+    if (offset)
+        query.offset = offset;
+    const filters = arrayFlag(command.flags.filter);
+    if (filters.length > 0)
+        query.filter = filters;
+    if (order) {
+        const [column, direction] = order.split(".");
+        query.order_by = column;
+        query.order_direction = direction === "desc" ? "desc" : "asc";
+    }
+    return query;
+}
+function withQuery(path, query) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined)
+            continue;
+        if (typeof value === "string") {
+            searchParams.set(key, value);
+        }
+        else {
+            for (const item of value)
+                searchParams.append(key, item);
+        }
+    }
+    const queryString = searchParams.toString();
+    return queryString ? `${path}?${queryString}` : path;
+}
+function jsonObjectFlag(command, key) {
+    const value = requiredFlag(command, key);
+    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 primaryKeyFlag(command) {
+    const value = requiredFlag(command, "pk");
+    const separator = value.indexOf("=");
+    if (separator <= 0)
+        throw new Error("--pk must use column=value");
+    return { column: value.slice(0, separator), value: value.slice(separator + 1) };
+}
+function arrayFlag(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "string")
+        return [value];
+    return [];
+}
+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;
+}