@luxorai/mcp 0.0.0-stage → 0.4.0

package/dist/tools/volumes.js

@@ -0,0 +1,102 @@
+import { z } from "zod";
+import { listQuery, ok, pathSchema, protoEnum, searchSchema, sessionIdSchema, tagsPatch, tagsSchema } from "./common.js";
+/** Volume size bounds the control plane accepts: 1 MiB … 100 GiB, in bytes. */
+const MIN_VOLUME_BYTES = 1_048_576; // 1 MiB
+const MAX_VOLUME_BYTES = 107_374_182_400; // 100 GiB
+/** Shared size-in-bytes schema for create + resize, range-checked before the call. */
+const sizeBytesSchema = z
+    .number()
+    .int()
+    .min(MIN_VOLUME_BYTES)
+    .max(MAX_VOLUME_BYTES)
+    .describe("Volume size in bytes. Must be between 1 MiB (1048576) and 100 GiB (107374182400).");
+export function registerVolumes(server, client) {
+    // ── Create ────────────────────────────────────────────────────────────────
+    server.tool("tenki_create_volume", "Create a workspace-scoped persistent volume — durable block storage that survives sandbox teardown. Defaults the workspace to the API key's first; override with workspace_id.", {
+        name: z.string().describe("Human-readable name for the volume."),
+        size_bytes: sizeBytesSchema,
+        workspace_id: z.string().optional().describe("Workspace to create the volume in (defaults to the key's first workspace)."),
+    }, async ({ name, size_bytes, workspace_id }) => {
+        const workspaceId = workspace_id ?? (await client.resolveOwner()).workspaceId;
+        return ok(await client.control("CreateVolume", {
+            ...(workspaceId ? { workspaceId } : {}),
+            name,
+            sizeBytes: size_bytes,
+        }));
+    });
+    // ── Get ───────────────────────────────────────────────────────────────────
+    server.tool("tenki_get_volume", "Fetch a single volume's metadata and current state by its id.", { volume_id: z.string().describe("The volume id, e.g. vol_….") }, async ({ volume_id }) => ok(await client.control("GetVolume", { volumeId: volume_id })));
+    // ── List ──────────────────────────────────────────────────────────────────
+    server.tool("tenki_list_volumes", "List persistent volumes in a workspace (defaults to the key's first workspace) with server-side search, state filter, sorting and optional state-count facets. Supports pagination.", {
+        workspace_id: z.string().optional().describe("Workspace to list volumes from (defaults to the key's first workspace)."),
+        search: searchSchema.describe("Free-text search over volume name/id (max 256 chars)."),
+        states: z.array(z.enum(["AVAILABLE", "IN_USE", "DELETING", "DELETED"])).max(16).optional().describe("Only volumes in any of these states."),
+        sort_by: z.enum(["NAME", "STATE", "SIZE_BYTES", "CREATED_AT"]).optional().describe("Column to sort by."),
+        sort_desc: z.boolean().optional().describe("Sort descending (default ascending)."),
+        include_facets: z.boolean().optional().describe("Also return per-state counts for the same filter scope."),
+        page_size: z.number().int().min(1).max(100).optional().describe("Max volumes to return per page (max 100)."),
+        page_token: z.string().optional().describe("Page token from a previous response's nextPageToken."),
+    }, async ({ workspace_id, search, states, sort_by, sort_desc, include_facets, page_size, page_token }) => {
+        const owner = await client.resolveOwner();
+        const workspaceId = workspace_id ?? owner.workspaceId;
+        return ok(await client.control("ListVolumes", {
+            ...(workspaceId ? { workspaceId } : {}),
+            ...(states && states.length ? { states: states.map((s) => protoEnum("VOLUME_STATE", s)) } : {}),
+            ...(sort_by ? { sortBy: protoEnum("VOLUME_SORT_FIELD", sort_by) } : {}),
+            ...listQuery(search, include_facets, sort_desc),
+            ...(page_size ? { pageSize: page_size } : {}),
+            ...(page_token ? { pageToken: page_token } : {}),
+        }));
+    });
+    // ── Update ────────────────────────────────────────────────────────────────
+    server.tool("tenki_update_volume", "Update a volume's name and/or tags (pass at least one). To change a volume's size use tenki_resize_volume instead.", {
+        volume_id: z.string().describe("The volume id to update."),
+        name: z.string().min(1).max(64).optional().describe("New human-readable name for the volume."),
+        tags: tagsSchema.describe("Replacement tag list. Pass [] (or clear_tags) to remove all tags."),
+        clear_tags: z.boolean().optional().describe("Remove all tags from the volume."),
+    }, async ({ volume_id, name, tags, clear_tags }) => {
+        const tagPatch = tagsPatch(tags, clear_tags);
+        if (name === undefined && !Object.keys(tagPatch).length) {
+            throw new Error("tenki_update_volume: pass name, tags, or clear_tags — nothing was sent.");
+        }
+        return ok(await client.control("UpdateVolume", {
+            volumeId: volume_id,
+            ...(name !== undefined ? { name } : {}),
+            ...tagPatch,
+        }));
+    });
+    // ── Delete ────────────────────────────────────────────────────────────────
+    server.tool("tenki_delete_volume", "Permanently delete a volume and destroy its data. Fails with VolumeInUse if the volume is still attached to a session — detach it first.", { volume_id: z.string().describe("The volume id to delete.") }, async ({ volume_id }) => ok(await client.control("DeleteVolume", { volumeId: volume_id })));
+    // ── Resize ────────────────────────────────────────────────────────────────
+    server.tool("tenki_resize_volume", "Change a volume's size in bytes (1 MiB … 100 GiB). Only a volume that has never been attached can be resized; once attached its size is fixed (failed_precondition), so create a new volume for a different size.", {
+        volume_id: z.string().describe("The volume id to resize."),
+        size_bytes: sizeBytesSchema,
+    }, async ({ volume_id, size_bytes }) => ok(await client.control("ResizeVolume", { volumeId: volume_id, newSizeBytes: size_bytes })));
+    // ── Attach ────────────────────────────────────────────────────────────────
+    server.tool("tenki_attach_volume", "Mount a volume into a running sandbox at an absolute path. Set read_only to mount without write access.", {
+        session_id: sessionIdSchema.describe("The sandbox session to attach the volume to."),
+        volume_id: z.string().describe("The volume id to attach."),
+        mount_path: pathSchema.describe("Absolute path inside the sandbox to mount at, e.g. /mnt/data."),
+        read_only: z.boolean().optional().describe("Mount the volume read-only (default false = read-write)."),
+    }, async ({ session_id, volume_id, mount_path, read_only }) => ok(
+    // AttachVolumeRequest nests the target under a `volume` sub-message
+    // (live-verified: a flat volumeId is rejected "volume: value is required").
+    await client.control("AttachVolume", {
+        sessionId: session_id,
+        volume: {
+            volumeId: volume_id,
+            mountPath: mount_path,
+            // proto field is `readonly` (one word); `readOnly` is an unknown field the API discards.
+            ...(read_only !== undefined ? { readonly: read_only } : {}),
+        },
+    })));
+    // ── Detach ────────────────────────────────────────────────────────────────
+    server.tool("tenki_detach_volume", "Unmount a volume from a sandbox session and sync it back to storage. A volume whose sync back is still pending (SYNC_PENDING) cannot be detached, even with force (failed_precondition): wait for the upload to finish or ask Tenki support to recover it. Set force to unplug an attached volume the guest cannot unmount — writes the guest has not flushed are lost.", {
+        session_id: sessionIdSchema.describe("The sandbox session to detach the volume from."),
+        volume_id: z.string().describe("The volume id to detach."),
+        force: z
+            .boolean()
+            .optional()
+            .describe("Force-unplug an ATTACHED volume (default false). Unflushed guest writes are lost. Never releases a SYNC_PENDING attachment; on a host that cannot force detach yet the API returns failed_precondition."),
+    }, async ({ session_id, volume_id, force }) => ok(await client.control("DetachVolume", { sessionId: session_id, volumeId: volume_id, ...(force ? { forceDetach: true } : {}) })));
+}

package/dist/tools/workspace.d.ts

@@ -0,0 +1,12 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { TenkiClient } from "../client.js";
+/**
+ * Workspace-level sandbox usage, CI runner sizes and wildcard preview domains.
+ *
+ * The workspace quota/retention settings RPCs (Get/UpdateWorkspaceSandboxSettings,
+ * Get/UpdateWorkspaceSnapshotRetentionSettings) were REMOVED from the API
+ * (tenki-app #5007, 2026-08-07; they 404 on staging and production), so their
+ * tools are gone. Quotas now come from the workspace plan and are read-only
+ * through tenki_get_workspace_usage.
+ */
+export declare function registerWorkspace(server: McpServer, client: TenkiClient): void;

package/dist/tools/workspace.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { ok } from "./common.js";
+/**
+ * Resolve which workspace an op targets: honour an explicit id, else fall back
+ * to the API key's first workspace (via WhoAmI, inside resolveOwner). Mirrors
+ * the live-verified n8n node's `resolveWorkspaceId` helper.
+ */
+async function resolveWorkspaceId(client, provided) {
+    if (provided && provided.trim())
+        return provided.trim();
+    const owner = await client.resolveOwner();
+    return owner.workspaceId;
+}
+/**
+ * Workspace-level sandbox usage, CI runner sizes and wildcard preview domains.
+ *
+ * The workspace quota/retention settings RPCs (Get/UpdateWorkspaceSandboxSettings,
+ * Get/UpdateWorkspaceSnapshotRetentionSettings) were REMOVED from the API
+ * (tenki-app #5007, 2026-08-07; they 404 on staging and production), so their
+ * tools are gone. Quotas now come from the workspace plan and are read-only
+ * through tenki_get_workspace_usage.
+ */
+export function registerWorkspace(server, client) {
+    server.tool("tenki_get_workspace_usage", "Get a workspace's sandbox usage against its plan limits (concurrent sandboxes, snapshots, templates, volumes, storage bytes, preview URLs) — each row has current + max. Use this for quota and cost visibility; the limits themselves come from the plan and are not editable through the API.", {
+        workspace_id: z
+            .string()
+            .optional()
+            .describe("Workspace to report on. Omit to use the API key's first workspace."),
+    }, async ({ workspace_id }) => {
+        const workspaceId = await resolveWorkspaceId(client, workspace_id);
+        return ok(await client.control("GetWorkspaceSandboxUsage", {
+            ...(workspaceId ? { workspaceId } : {}),
+        }));
+    });
+    server.tool("tenki_list_ci_runner_sizes", "List the Linux x64 runner sizes Tenki CI can run for a workspace — each runs-on label with its vCPUs and memory in GiB, smallest first, limited to the workspace's job-size limits — and defaultRunsOnLabel, the size a job gets when its runs-on names none. Use it to pick a runs-on label for a GitHub Actions workflow.", {
+        workspace_id: z
+            .string()
+            .optional()
+            .describe("Workspace to list sizes for. Omit to use the API key's first workspace."),
+    }, async ({ workspace_id }) => {
+        const workspaceId = await resolveWorkspaceId(client, workspace_id);
+        const resp = await client.control("ListCIRunnerSizes", { ...(workspaceId ? { workspaceId } : {}) });
+        // protojson omits empty fields; an empty workspace would otherwise come back as {}.
+        return ok({ ...resp, sizes: resp.sizes ?? [], defaultRunsOnLabel: resp.defaultRunsOnLabel ?? "" });
+    });
+    server.tool("tenki_get_workspace_preview_domains", "Read whether wildcard preview domains are enabled for a workspace, the per-region wildcard hostnames and their certificate readiness, and how many existing preview URLs use the wildcard scheme. Explains the `wildcard`/`wildcardStatus` fields on expose/preview responses.", {
+        workspace_id: z
+            .string()
+            .optional()
+            .describe("Workspace to read. Omit to use the API key's first workspace."),
+    }, async ({ workspace_id }) => {
+        const workspaceId = await resolveWorkspaceId(client, workspace_id);
+        return ok(await client.control("GetWorkspacePreviewDomains", { ...(workspaceId ? { workspaceId } : {}) }));
+    });
+    server.tool("tenki_update_workspace_preview_domains", "Enable or disable wildcard preview domains for a workspace. Enabling provisions one wildcard certificate per region and is limited to Pro-tier workspaces. DISABLING releases the certificates and existing wildcard-scheme preview URLs stop serving with a valid certificate — check wildcardPreviewUrlCount via tenki_get_workspace_preview_domains first.", {
+        enabled: z.boolean().describe("true to enable wildcard preview domains, false to disable them."),
+        workspace_id: z
+            .string()
+            .optional()
+            .describe("Workspace to update. Omit to use the API key's first workspace."),
+    }, async ({ enabled, workspace_id }) => {
+        const workspaceId = await resolveWorkspaceId(client, workspace_id);
+        return ok(await client.control("UpdateWorkspacePreviewDomains", {
+            ...(workspaceId ? { workspaceId } : {}),
+            enabled,
+        }));
+    });
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@luxorai/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "mcpName": "io.github.LuxorLabs/luxor-mcp",
+  "description": "Model Context Protocol server for Tenki Cloud — disposable microVM sandboxes for AI agents. Create sandboxes, run code, read/write files, run git, expose preview URLs — from any MCP client.",
+  "type": "module",
+  "bin": {
+    "tenki-mcp": "dist/index.js",
+    "luxor-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build",
+    "pretest": "npm run build",
+    "test": "node test/offline.test.mjs && node test/presubmission.test.mjs && node test/public-shapes.test.mjs && node test/exec-output.test.mjs && node test/http-input.test.mjs && node test/oauth-http.test.mjs && node test/security.test.mjs && node test/client-net.test.mjs && node test/wire-shapes.test.mjs",
+    "test:all": "npm run build && node test/run.mjs",
+    "test:offline": "npm run build && node test/offline.test.mjs"
+  },
+  "keywords": [
+    "tenki",
+    "mcp",
+    "model-context-protocol",
+    "sandbox",
+    "microvm",
+    "ai-agents",
+    "code-execution"
+  ],
+  "license": "MIT",
+  "author": "Tenki Cloud (https://tenki.cloud)",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "typescript": "^7.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LuxorLabs/tenki-mcp.git"
+  },
+  "homepage": "https://github.com/LuxorLabs/tenki-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/LuxorLabs/tenki-mcp/issues"
+  }
+}