@kosuke-ai/cli 1.0.1-next.4 → 1.0.1-next.6

package/dist/runtime/mcp-open-pr.js

@@ -0,0 +1,83 @@
+import { UsageError } from './invoke.js';
+import { data, failed } from './mcp-composite-support.js';
+/** `anthropic:sonnet__medium` names its provider; anything else does not. */
+function providerOf(model) {
+    if (typeof model !== 'string')
+        return null;
+    const prefix = model.split(':')[0];
+    return prefix === 'anthropic' || prefix === 'openai' ? prefix : null;
+}
+/**
+ * The provider a session's next turn runs on. The session's own model says so
+ * once it has one. Before its first message, or when its stored id is no
+ * longer recognised, the platform picks the model the way `access-status`
+ * reports it for the caller (scope `member`): their saved preference, then
+ * their Subscription's provider, then the workspace's credentials. That is
+ * the same resolution the send route runs, so its `defaultModel` is the model
+ * the turn would get, and it is pinned on the send so it stays that way.
+ * `ai-provider` is not consulted: its `defaultModel` is always null there.
+ * No model at all is a refusal: a wrong trigger sends the skill as chat text
+ * and reports success.
+ */
+export async function resolveProvider(session, projectId, context) {
+    const own = providerOf(session.model);
+    if (own)
+        return { provider: own, model: null };
+    const project = await context.call('projects_get', { projectId });
+    if (!project.ok)
+        return { failed: failed(project, 'projects_get') };
+    const workspaceId = data(project).orgId;
+    if (typeof workspaceId !== 'string' || !workspaceId) {
+        throw new UsageError('The project names no workspace, so the provider cannot be resolved.');
+    }
+    const access = await context.call('workspaces_access_status', { workspaceId, scope: 'member' });
+    if (!access.ok)
+        return { failed: failed(access, 'workspaces_access_status') };
+    const status = data(access);
+    const defaultModel = status.defaultModel;
+    const provider = providerOf(defaultModel);
+    if (provider)
+        return { provider, model: defaultModel };
+    const why = session.modelUnavailable === true
+        ? 'its model is no longer available'
+        : 'it has not run a turn yet';
+    const reason = typeof status.reason === 'string' && status.reason ? ` ${status.reason}` : '';
+    throw new UsageError(`This session has no model (${why}) and no provider is usable by you in this workspace, ` +
+        `so the provider cannot be told.${reason} Send one message with sessions_send and a ` +
+        `model, or connect a provider, then submit again.`);
+}
+/** The skill's own flags; a note that carries one would be read as one. */
+const OPEN_PR_FLAGS = /^(-d|--draft|-r|--reviewers|-e|--evidence)$/;
+export function openPrCommand(trigger, args) {
+    const parts = [`${trigger}open-pr`];
+    if (args.draft === true)
+        parts.push('-d');
+    const reviewers = names(args.reviewers, 'reviewers');
+    if (reviewers.length)
+        parts.push('-r', reviewers.join(','));
+    const evidence = names(args.evidence, 'evidence');
+    if (evidence.length)
+        parts.push('-e', evidence.join(','));
+    const notes = typeof args.notes === 'string' ? args.notes.trim() : '';
+    if (notes) {
+        if (notes.split(/\s+/).some((token) => OPEN_PR_FLAGS.test(token))) {
+            throw new UsageError('notes must not carry the skill flags (-d, -r, -e); use draft, reviewers and evidence.');
+        }
+        parts.push(notes);
+    }
+    return parts.join(' ');
+}
+/** One name per entry, trimmed; a comma or a space inside one would split it on the way in. */
+function names(value, what) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => String(item).trim())
+        .filter(Boolean)
+        .map((item) => {
+        if (/[,\s]/.test(item)) {
+            throw new UsageError(`${what} entries are single names or links; "${item}" is not.`);
+        }
+        return item;
+    });
+}

package/dist/runtime/mcp-redact.js

@@ -0,0 +1,31 @@
+/**
+ * What leaves a tool result. The platform returns a project's secret
+ * environment values in plaintext (`isSecret` is a UI hint there) and the
+ * project's Sentry DSN on every project row; an MCP result is pasted into a
+ * transcript, so both are replaced before anything is returned. Applied to
+ * every result, composite or generated, since responses are not modelled in
+ * the document and a shape can appear on more than one operation.
+ */
+export const REDACTED = '[redacted]';
+/** `https://<public key>@o123.ingest.sentry.io/456`: the key part is the credential. */
+const SENTRY_DSN = /^https?:\/\/[0-9a-f]{16,}@[^/\s]+\/\d+$/i;
+export function redact(value) {
+    if (Array.isArray(value))
+        return value.map(redact);
+    if (typeof value === 'string')
+        return SENTRY_DSN.test(value) ? REDACTED : value;
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const record = value;
+    const out = {};
+    for (const [key, item] of Object.entries(record)) {
+        if (key === 'sentryDsn' && typeof item === 'string')
+            out[key] = REDACTED;
+        else if (key === 'value' && record.isSecret === true && typeof item === 'string') {
+            out[key] = REDACTED;
+        }
+        else
+            out[key] = redact(item);
+    }
+    return out;
+}

package/dist/runtime/mcp-server.js

@@ -0,0 +1,219 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+import { tools as generatedTools } from '../generated/tools/index.js';
+import { createApiClient } from './client.js';
+import { UsageError } from './invoke.js';
+import { defaultAttachmentPolicy } from './mcp-attachments.js';
+import { compositeTools } from './mcp-composite.js';
+import { COMPOSITE_TOOLSET } from './mcp-composite-support.js';
+import { errorResult, invokeTool, toResult, UnknownTool, } from './mcp-invoke.js';
+import { version } from './version.js';
+export const ALL_TOOLSETS = 'all';
+/** The spec's tags, from the generated tools, then the hand-written set. */
+export function availableToolsets() {
+    return [...new Set(generatedTools.map((tool) => tool.toolset)), COMPOSITE_TOOLSET];
+}
+/**
+ * GET operations that change state. Each connects to the session's or the
+ * project's sandbox, which resumes it when it is paused and starts billing;
+ * `preview get` can start a deploy on top when the main sandbox is gone. A
+ * method alone cannot tell, so these are named, by their CLI command, and a
+ * test holds each name to a real operation.
+ */
+export const MUTATING_READS = new Set([
+    'preview get',
+    'preview shared',
+    'sessions files get',
+]);
+/**
+ * What `--read-only` keeps and what `readOnlyHint` says. The hint is what a
+ * client trusts to run a call without asking, so it must never be true for
+ * a tool that spends money.
+ */
+export function isReadOnly(tool) {
+    if (!('operation' in tool))
+        return tool.readOnly;
+    const { method, command } = tool.operation;
+    return method === 'get' && !MUTATING_READS.has(command.join(' '));
+}
+export function selectTools(options) {
+    const known = availableToolsets();
+    const wanted = options.toolsets?.length ? options.toolsets : [ALL_TOOLSETS];
+    for (const name of wanted) {
+        if (name !== ALL_TOOLSETS && !known.includes(name)) {
+            throw new UsageError(`Unknown toolset "${name}". Known: ${[ALL_TOOLSETS, ...known].join(', ')}.`);
+        }
+    }
+    const all = [...generatedTools, ...compositeTools];
+    return all.filter((tool) => (wanted.includes(ALL_TOOLSETS) || wanted.includes(tool.toolset)) &&
+        (!options.readOnly || isReadOnly(tool)));
+}
+/**
+ * What the client is shown per tool; the same for both kinds. A write is
+ * flagged destructive, the protocol's own default: nothing here can tell an
+ * additive write from one that cancels, resets or archives, and a wrong
+ * "additive" is another auto-approval.
+ */
+export function toolListing(tool) {
+    const readOnly = isReadOnly(tool);
+    return {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: { readOnlyHint: readOnly, destructiveHint: !readOnly, openWorldHint: true },
+    };
+}
+export function createMcpServer(options) {
+    const log = options.log ?? ((line) => process.stderr.write(line + '\n'));
+    const sleep = options.sleep ?? sleepUnlessAborted;
+    const now = options.now ?? Date.now;
+    const exposed = selectTools(options);
+    const byName = new Map(exposed.map((tool) => [tool.name, tool]));
+    const generatedByName = new Map(generatedTools.map((tool) => [tool.name, tool]));
+    const clients = new Map();
+    const clientFor = (anonymous) => {
+        let client = clients.get(anonymous);
+        if (!client) {
+            client = createApiClient({
+                apiUrl: options.apiUrl,
+                apiKey: anonymous ? null : options.apiKey,
+                ...(options.fetch ? { fetch: options.fetch } : {}),
+            });
+            clients.set(anonymous, client);
+        }
+        return client;
+    };
+    const context = { clientFor, attachments: options.attachments ?? defaultAttachmentPolicy() };
+    const validator = new AjvJsonSchemaValidator();
+    const validators = new Map();
+    const validate = (tool, args) => {
+        let check = validators.get(tool.name);
+        if (!check) {
+            check = validator.getValidator(tool.inputSchema);
+            validators.set(tool.name, check);
+        }
+        return check(args);
+    };
+    const server = new Server({ name: 'kosuke', version }, {
+        capabilities: { tools: {} },
+        instructions: 'Tools for the Kosuke platform. `ship`, `watch` and `submit` cover the common arc: ' +
+            'start a session, follow its job, open the pull request. Every other tool mirrors one ' +
+            'API operation and is named after its CLI command.',
+    });
+    server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: exposed.map(toolListing) }));
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        const tool = byName.get(request.params.name);
+        if (!tool)
+            return errorResult(new UnknownTool(request.params.name));
+        const args = request.params.arguments ?? {};
+        const checked = validate(tool, args);
+        if (!checked.valid)
+            return errorResult(new UsageError(checked.errorMessage));
+        try {
+            const invocation = 'operation' in tool
+                ? await invokeTool(tool, args, context)
+                : await tool.run(args, {
+                    call: async (name, callArgs) => {
+                        // Composite tools reach the platform only through a generated
+                        // tool, so their surface is the document's and nothing more,
+                        // and what they hand on is held to that tool's schema like a
+                        // call from outside would be.
+                        const target = generatedByName.get(name);
+                        if (!target)
+                            throw new Error(`${tool.name} asked for an unknown tool "${name}".`);
+                        // Checked here, at the one boundary every sub-call crosses,
+                        // so no loop path can send a request after the caller has gone.
+                        if (extra.signal.aborted)
+                            throw new Cancelled(tool.name, name);
+                        const inner = validate(target, callArgs);
+                        if (!inner.valid) {
+                            throw new UsageError(`${tool.name} → ${name}: ${inner.errorMessage}`);
+                        }
+                        return invokeTool(target, callArgs, context);
+                    },
+                    progress: async (message, progress, total) => {
+                        const progressToken = extra._meta?.progressToken;
+                        if (progressToken === undefined)
+                            return;
+                        await extra.sendNotification({
+                            method: 'notifications/progress',
+                            params: { progressToken, progress, ...(total ? { total } : {}), message },
+                        });
+                    },
+                    // A cancelled request must not leave a timer holding the loop.
+                    sleep: (ms) => abortable(sleep(ms, extra.signal), extra.signal),
+                    now,
+                    signal: extra.signal,
+                });
+            return toResult(invocation);
+        }
+        catch (error) {
+            if (!(error instanceof UsageError) && !(error instanceof Cancelled)) {
+                log(`kosuke mcp: ${tool.name} failed: ${String(error)}`);
+            }
+            return errorResult(error);
+        }
+    });
+    return server;
+}
+/** Thrown by a composite sub-call attempted after the caller cancelled; nobody is reading the answer. */
+class Cancelled extends Error {
+    constructor(tool, step) {
+        super(`${tool} was cancelled before ${step}.`);
+    }
+}
+/**
+ * The default wait. The timer is cleared when the signal fires, so a
+ * cancelled `watch` does not hold a referenced timer for the rest of its poll
+ * interval and delay the process exit after the transport closes.
+ */
+export function sleepUnlessAborted(ms, signal) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/** Settles when the work does, or at once when the signal fires first; for injected sleeps that ignore it. */
+function abortable(work, signal) {
+    if (!signal)
+        return work;
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const onAbort = () => resolve();
+        signal.addEventListener('abort', onAbort, { once: true });
+        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+export async function serveStdio(options) {
+    const server = createMcpServer(options);
+    const log = options.log ?? ((line) => process.stderr.write(line + '\n'));
+    const exposed = selectTools(options);
+    const attachments = options.attachments ?? defaultAttachmentPolicy();
+    // Both ends of the transport's life are wired before it opens: a transport
+    // that errors instead of closing would otherwise hold the process forever.
+    const ended = new Promise((resolve) => {
+        server.onclose = () => resolve();
+        server.onerror = (error) => {
+            log(`kosuke mcp: transport error: ${String(error)}`);
+            resolve();
+        };
+    });
+    await server.connect(new StdioServerTransport());
+    log(`kosuke mcp: serving ${exposed.length} tools ` +
+        `(${(options.toolsets?.length ? options.toolsets : [ALL_TOOLSETS]).join(', ')}` +
+        `${options.readOnly ? ', read-only' : ''}) for ${options.apiUrl}; ` +
+        `attachments from ${attachments.root}`);
+    await ended;
+}

package/dist/runtime/mcp-tool.js

@@ -0,0 +1,6 @@
+/** Argument names the tool schema owns; a field cannot take them. */
+export const BODY_ARGUMENT = 'body';
+export const ATTACHMENTS_ARGUMENT = 'attachments';
+export function toolNameFor(command) {
+    return command.join('_').replace(/-/g, '_');
+}

package/openapi.json

@@ -1733,6 +1733,140 @@
         }
       }
     },
+    "/api/projects/{projectId}/chat-sessions/{sessionId}/artifacts": {
+      "get": {
+        "operationId": "sessionsArtifactsList",
+        "summary": "List the session's artifacts, most recently changed first. Rows only: a body or a file url comes from reading one.",
+        "tags": ["sessions"],
+        "x-kosuke-command": ["sessions", "artifacts", "list"],
+        "parameters": [
+          {
+            "name": "projectId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+            }
+          },
+          {
+            "name": "sessionId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+            }
+          }
+        ],
+        "responses": {
+          "2XX": {
+            "description": "Success envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiSuccess"
+                }
+              }
+            }
+          },
+          "4XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "5XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/projects/{projectId}/chat-sessions/{sessionId}/artifacts/{artifactId}": {
+      "get": {
+        "operationId": "sessionsArtifactsGet",
+        "summary": "Read one artifact of the session: a markdown or html one carries its body, an image or a video a presigned url, its media type and its size.",
+        "tags": ["sessions"],
+        "x-kosuke-command": ["sessions", "artifacts", "get"],
+        "parameters": [
+          {
+            "name": "projectId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+            }
+          },
+          {
+            "name": "sessionId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+            }
+          },
+          {
+            "name": "artifactId",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "pattern": "^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$"
+            }
+          }
+        ],
+        "responses": {
+          "2XX": {
+            "description": "Success envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiSuccess"
+                }
+              }
+            }
+          },
+          "4XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          },
+          "5XX": {
+            "description": "Error envelope",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ApiError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/projects/{projectId}/chat-sessions/{sessionId}/jobs/chat": {
       "post": {
         "operationId": "sessionsSend",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kosuke-ai/cli",
-  "version": "1.0.1-next.4",
+  "version": "1.0.1-next.6",
   "description": "Kosuke platform CLI. The client customers install to drive app.kosuke.ai from their own machine.",
   "license": "MIT",
   "repository": {
@@ -29,6 +29,7 @@
     "prepack": "npm run build"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "commander": "^14.0.0",
     "openapi-fetch": "^0.14.0"
   },