@ornncompute/cli 0.2.24 → 1.0.34

package/vendor/capabilities/capabilities/staff-gtm.d.ts

@@ -1,142 +0,0 @@
-import { z } from "zod";
-export declare const gtmCompanyListInput: z.ZodObject<{
-    q: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const gtmCompanyListCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmCompanyWriteInput: z.ZodObject<{
-    confirm: z.ZodOptional<z.ZodBoolean>;
-    name: z.ZodString;
-    ownerTags: z.ZodDefault<z.ZodString>;
-    notes: z.ZodOptional<z.ZodString>;
-    companyId: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const gtmCompanyWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmDealListInput: z.ZodObject<{
-    q: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const gtmDealListCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmDealWriteInput: z.ZodObject<{
-    dealId: z.ZodOptional<z.ZodNumber>;
-    listingId: z.ZodOptional<z.ZodString>;
-    customer: z.ZodOptional<z.ZodString>;
-    owner: z.ZodOptional<z.ZodString>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmDealWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmCommentListInput: z.ZodObject<{
-    dealId: z.ZodOptional<z.ZodNumber>;
-    companyId: z.ZodOptional<z.ZodNumber>;
-    taskId: z.ZodOptional<z.ZodNumber>;
-    field: z.ZodOptional<z.ZodEnum<{
-        name: "name";
-        notes: "notes";
-        owner_tags: "owner_tags";
-        tickets: "tickets";
-    }>>;
-}, z.core.$strip>;
-export declare const gtmCommentListCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmCommentWriteInput: z.ZodObject<{
-    commentId: z.ZodOptional<z.ZodNumber>;
-    parentId: z.ZodOptional<z.ZodNumber>;
-    body: z.ZodString;
-    bid: z.ZodDefault<z.ZodBoolean>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-    dealId: z.ZodOptional<z.ZodNumber>;
-    companyId: z.ZodOptional<z.ZodNumber>;
-    taskId: z.ZodOptional<z.ZodNumber>;
-    field: z.ZodOptional<z.ZodEnum<{
-        name: "name";
-        notes: "notes";
-        owner_tags: "owner_tags";
-        tickets: "tickets";
-    }>>;
-}, z.core.$strip>;
-export declare const gtmCommentWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmWorkspaceShowInput: z.ZodObject<{}, z.core.$strip>;
-export declare const gtmWorkspaceShowCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmTaskListInput: z.ZodObject<{
-    q: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const gtmTaskListCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmTaskWriteInput: z.ZodObject<{
-    taskId: z.ZodOptional<z.ZodNumber>;
-    title: z.ZodString;
-    body: z.ZodDefault<z.ZodString>;
-    companyId: z.ZodNumber;
-    dealId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    assignee: z.ZodString;
-    status: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-        done: "done";
-    }>>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmTaskWriteCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmCompanyDeleteInput: z.ZodObject<{
-    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmCompanyDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmCommentDeleteInput: z.ZodObject<{
-    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmCommentDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmTaskDeleteInput: z.ZodObject<{
-    [x: string]: z.ZodNumber | z.ZodOptional<z.ZodBoolean>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmTaskDeleteCapability: import("../capability.ts").Capability<unknown, unknown>;
-/**
- * Listing verbs. GTM never touches a Commerce table directly: these call
- * Commerce's own listing routes through the gateway, exactly as the staff app
- * does. Nothing here writes a gtm_ row, and nothing in the CRM constrains a
- * listing.
- */
-export declare const gtmListingListInput: z.ZodObject<{
-    gpuType: z.ZodOptional<z.ZodString>;
-    state: z.ZodOptional<z.ZodEnum<{
-        delisted: "delisted";
-        available: "available";
-        internal: "internal";
-    }>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const gtmListingListCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmListingUpdateInput: z.ZodObject<{
-    listingId: z.ZodString;
-    buyNowRatePerGpuHour: z.ZodOptional<z.ZodString>;
-    costPerGpuHour: z.ZodOptional<z.ZodString>;
-    monthToMonth: z.ZodOptional<z.ZodBoolean>;
-    allowsDepositPlan: z.ZodOptional<z.ZodBoolean>;
-    downPaymentPct: z.ZodOptional<z.ZodString>;
-    capacityNodes: z.ZodOptional<z.ZodNumber>;
-    state: z.ZodOptional<z.ZodEnum<{
-        delisted: "delisted";
-        available: "available";
-        internal: "internal";
-    }>>;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmListingUpdateCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const gtmTaskActivityListInput: z.ZodObject<{
-    taskId: z.ZodNumber;
-}, z.core.$strip>;
-export declare const gtmTaskActivityListCapability: import("../capability.ts").Capability<unknown, unknown>;
-/**
- * Bulk owner-tag reassignment. This is the one GTM edit that is genuinely
- * N-at-a-time — a book of companies moving to a new owner — and doing it one
- * confirmation at a time is both slow and easy to half-finish. Every other
- * bulk case is a loop over the single-record verbs.
- */
-export declare const gtmCompanyBulkRetagInput: z.ZodObject<{
-    companyIds: z.ZodArray<z.ZodNumber>;
-    ownerTags: z.ZodString;
-    confirm: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const gtmCompanyBulkRetagCapability: import("../capability.ts").Capability<unknown, unknown>;
-export declare const staffGTMCapabilities: import("../capability.ts").Capability<unknown, unknown>[];

package/vendor/capabilities/capabilities/staff-gtm.js

@@ -1,521 +0,0 @@
-import { z } from "zod";
-import { defineStaffMcpCapability, preview } from "../capability.js";
-import { seg } from "./staff-shared.js";
-const companyFields = {
-    name: z.string().min(1),
-    ownerTags: z.string().default(""),
-    /** The editable company summary that sits above the comment thread. */
-    notes: z.string().optional(),
-};
-/** Narrowing every list accepts, so an agent need not hold the whole table. */
-const listFilterFields = {
-    q: z.string().min(1).optional(),
-    limit: z.number().int().positive().max(500).optional(),
-};
-function listQuery(parsed) {
-    const parts = [];
-    if (parsed.q)
-        parts.push(`q=${encodeURIComponent(parsed.q)}`);
-    if (parsed.limit)
-        parts.push(`limit=${parsed.limit}`);
-    return parts.length ? `?${parts.join("&")}` : "";
-}
-export const gtmCompanyListInput = z.object({ ...listFilterFields });
-export const gtmCompanyListCapability = defineStaffMcpCapability({
-    id: "gtm.company.list",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: list plaintext CRM companies, their owner tags and summary notes. Narrow with q, cap with limit. A company's running discussion is its comment thread.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/gtm/companies" },
-    input: gtmCompanyListInput,
-    execute: (ctx, input) => ctx.fetch(`/internal/v1/gtm/companies${listQuery(gtmCompanyListInput.parse(input))}`, {
-        method: "GET",
-    }),
-});
-export const gtmCompanyWriteInput = z.object({
-    companyId: z.number().int().positive().optional(),
-    ...companyFields,
-    confirm: z.boolean().optional(),
-});
-export const gtmCompanyWriteCapability = defineStaffMcpCapability({
-    id: "gtm.company.write",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: create a plaintext CRM company, or replace its name, owner tags and summary notes when companyId is supplied. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/v1/gtm/companies" },
-    input: gtmCompanyWriteInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmCompanyWriteInput.parse(input);
-        const body = { name: parsed.name, owner_tags: parsed.ownerTags };
-        if (parsed.notes !== undefined)
-            body.notes = parsed.notes;
-        if (!ctx.confirmed) {
-            return preview("gtm.company.write", { companyId: parsed.companyId, ...body });
-        }
-        return ctx.fetch(parsed.companyId
-            ? `/internal/v1/gtm/companies/${seg(String(parsed.companyId))}`
-            : "/internal/v1/gtm/companies", { method: parsed.companyId ? "PATCH" : "POST", body });
-    },
-});
-export const gtmDealListInput = z.object({ ...listFilterFields });
-export const gtmDealListCapability = defineStaffMcpCapability({
-    id: "gtm.deal.list",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: list manually entered deals. Each deal has only customer, Ornn owner, supplier, and GPU type. Narrow with q, cap with limit.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/gtm/deals" },
-    input: gtmDealListInput,
-    execute: (ctx, input) => ctx.fetch(`/internal/v1/gtm/deals${listQuery(gtmDealListInput.parse(input))}`, {
-        method: "GET",
-    }),
-});
-export const gtmDealWriteInput = z.object({
-    dealId: z.number().int().positive().optional(),
-    /** Required to create: a deal is that Commerce listing's GTM record. Cannot change. */
-    listingId: z.string().uuid().optional(),
-    /** Optional extras, unspecified until filled in. "" clears one. */
-    customer: z.string().optional(),
-    owner: z.string().optional(),
-    confirm: z.boolean().optional(),
-});
-export const gtmDealWriteCapability = defineStaffMcpCapability({
-    id: "gtm.deal.write",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: 'GTM staff only: a deal is the GTM record of one Commerce listing, and its comments hang off it. Create one with listingId (one deal per listing; a second is a conflict), or update one with dealId. customer and owner are optional; on update only the fields you pass change, and "" clears one. The listing cannot change. A bid is a comment with bid: true (see comment_write); the newest one is the current bid. Requires confirm: true.',
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/v1/gtm/deals" },
-    input: gtmDealWriteInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmDealWriteInput.parse(input);
-        if (parsed.dealId === undefined && parsed.listingId === undefined) {
-            throw new Error("listingId is required to create a deal");
-        }
-        if (parsed.dealId !== undefined && parsed.listingId !== undefined) {
-            throw new Error("a deal's listing cannot change; omit listingId when updating");
-        }
-        // Only what the caller passed is sent: omitted is unspecified on create
-        // and untouched on update; "" clears.
-        const body = {};
-        for (const [key, value] of [
-            ["listing_id", parsed.listingId],
-            ["customer", parsed.customer],
-            ["owner", parsed.owner],
-        ]) {
-            if (value !== undefined)
-                body[key] = value;
-        }
-        if (!ctx.confirmed) {
-            return preview("gtm.deal.write", { dealId: parsed.dealId, ...body });
-        }
-        return ctx.fetch(parsed.dealId
-            ? `/internal/v1/gtm/deals/${seg(String(parsed.dealId))}`
-            : "/internal/v1/gtm/deals", { method: parsed.dealId ? "PATCH" : "POST", body });
-    },
-});
-/** Company fields that carry their own side thread. */
-const companyField = z.enum(["name", "owner_tags", "notes", "tickets"]);
-/** A thread hangs off one deal, one company (or one of its fields), or one ticket. */
-const commentThread = {
-    dealId: z.number().int().positive().optional(),
-    companyId: z.number().int().positive().optional(),
-    taskId: z.number().int().positive().optional(),
-    /** With companyId: that field's side thread instead of the main one. */
-    field: companyField.optional(),
-};
-export const gtmCommentListInput = z.object(commentThread);
-export const gtmCommentListCapability = defineStaffMcpCapability({
-    id: "gtm.comment.list",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: list the plaintext comment thread for one deal, one company (or one company field with field), or one ticket (taskId), replies included. A reply carries parent_id.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/gtm/deals/{dealId}/comments" },
-    input: gtmCommentListInput,
-    execute: (ctx, input) => {
-        const parsed = gtmCommentListInput.parse(input);
-        const query = parsed.field ? `?field=${encodeURIComponent(parsed.field)}` : "";
-        return ctx.fetch(commentThreadPath(parsed) + query, { method: "GET" });
-    },
-});
-export const gtmCommentWriteInput = z.object({
-    ...commentThread,
-    commentId: z.number().int().positive().optional(),
-    /** Set to reply to an existing comment. Threads are one level deep. */
-    parentId: z.number().int().positive().optional(),
-    body: z.string().min(1),
-    bid: z.boolean().default(false),
-    confirm: z.boolean().optional(),
-});
-export const gtmCommentWriteCapability = defineStaffMcpCapability({
-    id: "gtm.comment.write",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: append a plaintext comment to a deal, a company (or one company field with field), or a ticket (taskId); reply to one with parentId, or replace one when commentId is supplied. bid=true adds only the BID tag and changes no other behavior. Mention a teammate by writing @name in the body. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/v1/gtm/deals/{dealId}/comments" },
-    input: gtmCommentWriteInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmCommentWriteInput.parse(input);
-        if (!parsed.commentId && !parsed.dealId && !parsed.companyId && !parsed.taskId) {
-            throw new Error("dealId, companyId or taskId is required when creating a comment");
-        }
-        const body = {
-            body: parsed.body,
-            tag: parsed.bid ? "BID" : null,
-        };
-        if (parsed.parentId) {
-            body.parent_id = parsed.parentId;
-        }
-        if (parsed.field) {
-            body.field = parsed.field;
-        }
-        if (!ctx.confirmed) {
-            return preview("gtm.comment.write", {
-                dealId: parsed.dealId,
-                companyId: parsed.companyId,
-                taskId: parsed.taskId,
-                commentId: parsed.commentId,
-                ...body,
-            });
-        }
-        return ctx.fetch(parsed.commentId
-            ? `/internal/v1/gtm/comments/${seg(String(parsed.commentId))}`
-            : commentThreadPath(parsed), { method: parsed.commentId ? "PATCH" : "POST", body });
-    },
-});
-/** A comment thread hangs off exactly one subject. */
-function commentThreadPath(parsed) {
-    if (parsed.companyId) {
-        return `/internal/v1/gtm/companies/${seg(String(parsed.companyId))}/comments`;
-    }
-    if (parsed.taskId) {
-        return `/internal/v1/gtm/tasks/${seg(String(parsed.taskId))}/comments`;
-    }
-    if (parsed.dealId) {
-        return `/internal/v1/gtm/deals/${seg(String(parsed.dealId))}/comments`;
-    }
-    throw new Error("dealId, companyId or taskId is required");
-}
-export const gtmWorkspaceShowInput = z.object({});
-export const gtmWorkspaceShowCapability = defineStaffMcpCapability({
-    id: "gtm.workspace.show",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: show companies tagged to the signed-in user, deals they own, mentions of them (answered once they comment in that thread), and tickets assigned to them.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/gtm/me" },
-    input: gtmWorkspaceShowInput,
-    execute: (ctx) => ctx.fetch("/internal/v1/gtm/me", { method: "GET" }),
-});
-export const gtmTaskListInput = z.object({ ...listFilterFields });
-export const gtmTaskListCapability = defineStaffMcpCapability({
-    id: "gtm.task.list",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: list isolated CRM tickets tied to companies. Narrow with q, cap with limit.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/gtm/tasks" },
-    input: gtmTaskListInput,
-    execute: (ctx, input) => ctx.fetch(`/internal/v1/gtm/tasks${listQuery(gtmTaskListInput.parse(input))}`, {
-        method: "GET",
-    }),
-});
-export const gtmTaskWriteInput = z
-    .object({
-    taskId: z.number().int().positive().optional(),
-    title: z.string().min(1),
-    body: z.string().default(""),
-    companyId: z.number().int().positive(),
-    dealId: z.number().int().positive().nullable().optional(),
-    assignee: z.string().min(1),
-    status: z.enum(["open", "done"]).optional(),
-    confirm: z.boolean().optional(),
-})
-    // Creating defaults to open; updating replaces the whole ticket, so an
-    // omitted status would be sent as empty and rejected by Commerce. Catch it
-    // here instead of after the caller has confirmed.
-    .refine((value) => value.taskId === undefined || value.status !== undefined, {
-    message: "status is required when updating a ticket",
-    path: ["status"],
-});
-export const gtmTaskWriteCapability = defineStaffMcpCapability({
-    id: "gtm.task.write",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: create a company ticket, or replace one when taskId is supplied. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "POST", path: "/internal/v1/gtm/tasks" },
-    input: gtmTaskWriteInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmTaskWriteInput.parse(input);
-        const body = {
-            title: parsed.title,
-            body: parsed.body,
-            company_id: parsed.companyId,
-            deal_id: parsed.dealId ?? null,
-            assignee: parsed.assignee,
-            status: parsed.status,
-        };
-        if (!ctx.confirmed) {
-            return preview("gtm.task.write", { taskId: parsed.taskId, ...body });
-        }
-        return ctx.fetch(parsed.taskId
-            ? `/internal/v1/gtm/tasks/${seg(String(parsed.taskId))}`
-            : "/internal/v1/gtm/tasks", { method: parsed.taskId ? "PATCH" : "POST", body });
-    },
-});
-/**
- * Delete verbs. Each takes the record id, previews first, and maps onto the
- * matching DELETE route. Deleting a deal removes its comments with it; a
- * company refuses while deals or tickets still name it.
- */
-function gtmDeleteCapability(entity, idKey, route, consequence) {
-    const input = z.object({
-        [idKey]: z.number().int().positive(),
-        confirm: z.boolean().optional(),
-    });
-    const capability = defineStaffMcpCapability({
-        id: `gtm.${entity}.delete`,
-        domain: "gtm",
-        roles: ["reviewer", "admin"],
-        description: `GTM staff only: delete one ${entity}. ${consequence} Requires confirm: true.`,
-        mutation: "preview-confirm",
-        http: { method: "DELETE", path: `${route}/{${idKey}}` },
-        input,
-        execute: async (ctx, raw) => {
-            const parsed = input.parse(raw);
-            const id = parsed[idKey];
-            if (!ctx.confirmed) {
-                return preview(`gtm.${entity}.delete`, { [idKey]: id });
-            }
-            return ctx.fetch(`${route}/${seg(String(id))}`, { method: "DELETE" });
-        },
-    });
-    return { input, capability };
-}
-const companyDelete = gtmDeleteCapability("company", "companyId", "/internal/v1/gtm/companies", "Refused while the company still has deals or tickets.");
-export const gtmCompanyDeleteInput = companyDelete.input;
-export const gtmCompanyDeleteCapability = companyDelete.capability;
-const commentDelete = gtmDeleteCapability("comment", "commentId", "/internal/v1/gtm/comments", "Removes only that comment.");
-export const gtmCommentDeleteInput = commentDelete.input;
-export const gtmCommentDeleteCapability = commentDelete.capability;
-const taskDelete = gtmDeleteCapability("task", "taskId", "/internal/v1/gtm/tasks", "Removes only that ticket.");
-export const gtmTaskDeleteInput = taskDelete.input;
-export const gtmTaskDeleteCapability = taskDelete.capability;
-/**
- * Listing verbs. GTM never touches a Commerce table directly: these call
- * Commerce's own listing routes through the gateway, exactly as the staff app
- * does. Nothing here writes a gtm_ row, and nothing in the CRM constrains a
- * listing.
- */
-export const gtmListingListInput = z.object({
-    gpuType: z.string().optional(),
-    state: z.enum(["available", "internal", "delisted"]).optional(),
-    /** Commerce serves at most 100 per page; pass nextCursor back for the rest. */
-    limit: z.number().int().positive().max(100).optional(),
-    cursor: z.string().optional(),
-});
-export const gtmListingListCapability = defineStaffMcpCapability({
-    id: "gtm.listing.list",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: list Commerce listings (each can carry one GTM deal), optionally filtered by GPU type or state. Returns at most 100 per call with nextCursor; pass it back as cursor for the next page. Includes provider (staff-only). Read-only; this is Commerce's catalog, not CRM data.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/listings" },
-    input: gtmListingListInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmListingListInput.parse(input);
-        const parts = [`limit=${encodeURIComponent(String(parsed.limit ?? 50))}`];
-        if (parsed.gpuType)
-            parts.push(`q=${encodeURIComponent(parsed.gpuType)}`);
-        if (parsed.state)
-            parts.push(`state=${encodeURIComponent(parsed.state)}`);
-        if (parsed.cursor)
-            parts.push(`cursor=${encodeURIComponent(parsed.cursor)}`);
-        const page = (await ctx.fetch(`/internal/v1/listings?${parts.join("&")}`, {
-            method: "GET",
-        }));
-        return {
-            listings: (page.listings ?? []).map(staffListing),
-            nextCursor: page.nextCursor ?? null,
-        };
-    },
-});
-export const gtmListingUpdateInput = z.object({
-    listingId: z.string().uuid(),
-    buyNowRatePerGpuHour: z.string().optional(),
-    costPerGpuHour: z.string().optional(),
-    /** true = month to month, false = the fixed window the listing already carries. */
-    monthToMonth: z.boolean().optional(),
-    allowsDepositPlan: z.boolean().optional(),
-    downPaymentPct: z.string().optional(),
-    capacityNodes: z.number().int().positive().optional(),
-    state: z.enum(["available", "internal", "delisted"]).optional(),
-    confirm: z.boolean().optional(),
-});
-export const gtmListingUpdateCapability = defineStaffMcpCapability({
-    id: "gtm.listing.update",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: update a Commerce listing's commercial terms — buy-now rate, cost, term and deposit plan — plus capacity or state. Setting a buy-now rate also enables buy-now, otherwise the rate would be inert. Commerce owns the record; this is its own PATCH, not a CRM write. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/internal/v1/listings/{listingId}" },
-    input: gtmListingUpdateInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmListingUpdateInput.parse(input);
-        const body = listingPatchBody(parsed);
-        if (Object.keys(body).length === 0) {
-            throw new Error("supply at least one field to update");
-        }
-        if (!ctx.confirmed) {
-            return preview("gtm.listing.update", { listingId: parsed.listingId, ...body });
-        }
-        return patchListing(ctx, parsed.listingId, body);
-    },
-});
-/**
- * Strip true operator identity before it reaches an MCP client. Facility and
- * region are allowed; operator ids and provider names are not. Every listing
- * this module returns -- list, update, and the apply result -- goes through it.
- */
-/**
- * GTM tools are staff-only, behind the reviewer boundary, so they keep the
- * listing's provider -- a deal's supplier is its listing's. The operator
- * record's own id and legal name still stay out.
- */
-function staffListing(raw) {
-    const listing = raw;
-    const { operatorId: _operatorId, operatorName: _operatorName, ...safe } = listing;
-    return safe;
-}
-/**
- * The listing PATCH is a compare-and-set: it refuses without the version the
- * row was read at. Read it here so a caller never has to guess, and a listing
- * changed in between fails loudly rather than being clobbered.
- */
-async function patchListing(ctx, listingId, body) {
-    const current = (await ctx.fetch(`/internal/v1/listings/${seg(listingId)}`, {
-        method: "GET",
-    }));
-    if (typeof current.version !== "number") {
-        throw new Error("listing did not report a version to update against");
-    }
-    const updated = await ctx.fetch(`/internal/v1/listings/${seg(listingId)}`, {
-        method: "PATCH",
-        body: { ...body, version: current.version },
-    });
-    return staffListing(updated);
-}
-function listingPatchBody(parsed) {
-    const body = {};
-    if (parsed.buyNowRatePerGpuHour !== undefined) {
-        body.buyNowRatePerGpuHour = parsed.buyNowRatePerGpuHour;
-        // A rate with buy-now still disabled would change nothing a buyer sees.
-        body.buyNowEnabled = true;
-    }
-    if (parsed.costPerGpuHour !== undefined)
-        body.costPerGpuHour = parsed.costPerGpuHour;
-    if (parsed.monthToMonth !== undefined)
-        body.monthToMonth = parsed.monthToMonth;
-    if (parsed.allowsDepositPlan !== undefined)
-        body.allowsDepositPlan = parsed.allowsDepositPlan;
-    if (parsed.downPaymentPct !== undefined)
-        body.downPaymentPct = parsed.downPaymentPct;
-    if (parsed.capacityNodes !== undefined)
-        body.capacityNodes = parsed.capacityNodes;
-    if (parsed.state !== undefined)
-        body.state = parsed.state;
-    return body;
-}
-export const gtmTaskActivityListInput = z.object({
-    taskId: z.number().int().positive(),
-});
-export const gtmTaskActivityListCapability = defineStaffMcpCapability({
-    id: "gtm.task.activity.list",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: read one ticket's history — its creation and the field changes recorded against it, oldest first. Its comments are gtm.comment.list with taskId.",
-    mutation: "read",
-    http: { method: "GET", path: "/internal/v1/gtm/tasks/{taskId}/activity" },
-    input: gtmTaskActivityListInput,
-    execute: (ctx, input) => {
-        const parsed = gtmTaskActivityListInput.parse(input);
-        return ctx.fetch(`/internal/v1/gtm/tasks/${seg(String(parsed.taskId))}/activity`, {
-            method: "GET",
-        });
-    },
-});
-/**
- * Bulk owner-tag reassignment. This is the one GTM edit that is genuinely
- * N-at-a-time — a book of companies moving to a new owner — and doing it one
- * confirmation at a time is both slow and easy to half-finish. Every other
- * bulk case is a loop over the single-record verbs.
- */
-export const gtmCompanyBulkRetagInput = z.object({
-    companyIds: z.array(z.number().int().positive()).min(1).max(200),
-    ownerTags: z.string(),
-    confirm: z.boolean().optional(),
-});
-export const gtmCompanyBulkRetagCapability = defineStaffMcpCapability({
-    id: "gtm.company.bulk_retag",
-    domain: "gtm",
-    roles: ["reviewer", "admin"],
-    description: "GTM staff only: set the same owner tags on many companies at once, for moving a book to a new owner. Names, notes and comments are untouched. The preview lists every company it would change. Requires confirm: true.",
-    mutation: "preview-confirm",
-    http: { method: "PATCH", path: "/internal/v1/gtm/companies/{companyId}" },
-    input: gtmCompanyBulkRetagInput,
-    execute: async (ctx, input) => {
-        const parsed = gtmCompanyBulkRetagInput.parse(input);
-        const ids = [...new Set(parsed.companyIds)];
-        if (!ctx.confirmed) {
-            return preview("gtm.company.bulk_retag", { companyIds: ids, ownerTags: parsed.ownerTags });
-        }
-        // PATCH replaces the company's name as well, so the current names are read
-        // once up front rather than per row. Omitting notes preserves them.
-        // Commerce owns no bulk route, so partial progress is reported rather than
-        // rolled back; re-running is safe.
-        const all = (await ctx.fetch("/internal/v1/gtm/companies", { method: "GET" }));
-        const names = new Map(all.map((company) => [company.id, company.name]));
-        const updated = [];
-        const failed = [];
-        for (const companyId of ids) {
-            const name = names.get(companyId);
-            if (name === undefined) {
-                failed.push({ companyId, error: "no such company" });
-                continue;
-            }
-            try {
-                updated.push(await ctx.fetch(`/internal/v1/gtm/companies/${seg(String(companyId))}`, {
-                    method: "PATCH",
-                    body: { name, owner_tags: parsed.ownerTags },
-                }));
-            }
-            catch (error) {
-                failed.push({ companyId, error: error instanceof Error ? error.message : String(error) });
-            }
-        }
-        return { updated, failed };
-    },
-});
-export const staffGTMCapabilities = [
-    gtmCompanyListCapability,
-    gtmCompanyWriteCapability,
-    gtmCompanyDeleteCapability,
-    gtmCompanyBulkRetagCapability,
-    gtmDealListCapability,
-    gtmDealWriteCapability,
-    gtmCommentListCapability,
-    gtmCommentWriteCapability,
-    gtmCommentDeleteCapability,
-    gtmTaskListCapability,
-    gtmTaskWriteCapability,
-    gtmTaskDeleteCapability,
-    gtmTaskActivityListCapability,
-    gtmListingListCapability,
-    gtmListingUpdateCapability,
-    gtmWorkspaceShowCapability,
-];