@anchrd/colab-sdk 0.1.21 → 0.1.23

package/dist/mcps/mcps.js

@@ -0,0 +1,241 @@
+import { z } from "zod";
+import { idSchema } from "../ids/ids.js";
+import { Limit } from "../list-input.js";
+import { MachineId } from "../machines/machines.js";
+import { UserId } from "../users/users.js";
+// A person's own MCP servers (E144, #802, Einstellungen › MCPs): connected from the catalog below or
+// as their own, used by their personal Operators (E143) directly from the run's container (E80);
+// Colab passes nothing through (E2). `operator_mcp_*`, always the caller's own, admin mode or not.
+//
+// ⚠️ The sign-in goes in and never comes out: no answer carries it, and no field of an answer is
+// called `key`, `secret`, `token` or `password` (`/mcp` would strike it). Its field in the inputs is
+// `value`; a header's name is no secret and is answered.
+export const McpId = idSchema("mcp").describe("The MCP's id, `mcp_…`, as operator_mcp_list names it.");
+// How Colab signs in at the MCP server: OAuth in the person's browser, a bearer token, one header with
+// a value, or nothing.
+export const McpAuth = z.enum(["oauth", "bearer", "header", "none"]);
+// `running` ("Läuft"): the last check listed its tools. `expired` ("Anmeldung abgelaufen"): the
+// server refused the sign-in (an OAuth sign-in that no longer refreshes, a token it no longer takes);
+// "Neu anmelden" helps. `unreachable`: the server did not answer as an MCP server. `pending`: an
+// OAuth sign-in was started and is not finished; its address is `authorizeUrl`.
+export const McpState = z.enum(["running", "expired", "unreachable", "pending"]);
+// The prepared MCPs (Einstellungen › MCPs › Katalog). Their addresses and sign-ins are data here, the
+// UI reads them and names each by its `id` in its messages. `signIn` is who the person signs in with
+// ("angemeldet mit Google"). ⚠️ The addresses are the providers' remote MCP servers as published in
+// October 2026; each is proven only on the stage with a real account (#35), locally none answers.
+export const mcpCatalog = [
+    {
+        id: "gmail",
+        name: "Gmail",
+        url: "https://gmailmcp.googleapis.com/mcp/v1",
+        auth: "oauth",
+        signIn: "Google",
+        color: "#c5221f",
+        initials: "G",
+    },
+    {
+        id: "calendar",
+        name: "Google Calendar",
+        url: "https://calendarmcp.googleapis.com/mcp/v1",
+        auth: "oauth",
+        signIn: "Google",
+        color: "#1a73e8",
+        initials: "K",
+    },
+    {
+        id: "drive",
+        name: "Google Drive",
+        url: "https://drivemcp.googleapis.com/mcp/v1",
+        auth: "oauth",
+        signIn: "Google",
+        color: "#188038",
+        initials: "D",
+    },
+    {
+        id: "slack",
+        name: "Slack",
+        url: "https://mcp.slack.com/mcp",
+        auth: "oauth",
+        signIn: "Slack",
+        color: "#4a154b",
+        initials: "Sl",
+    },
+    {
+        id: "teams",
+        name: "Microsoft Teams",
+        url: "https://agent365.svc.cloud.microsoft/agents/servers/mcp_TeamsServer",
+        auth: "oauth",
+        signIn: "Microsoft",
+        color: "#5059c9",
+        initials: "T",
+    },
+    {
+        id: "outlook",
+        name: "Outlook",
+        url: "https://agent365.svc.cloud.microsoft/agents/servers/mcp_MailTools",
+        auth: "oauth",
+        signIn: "Microsoft",
+        color: "#0f6cbd",
+        initials: "O",
+    },
+    {
+        id: "hubspot",
+        name: "HubSpot",
+        url: "https://mcp.hubspot.com",
+        auth: "oauth",
+        signIn: "HubSpot",
+        color: "#c2410c",
+        initials: "H",
+    },
+    {
+        id: "notion",
+        name: "Notion",
+        url: "https://mcp.notion.com/mcp",
+        auth: "oauth",
+        signIn: "Notion",
+        color: "#111111",
+        initials: "N",
+    },
+];
+export const McpCatalogId = z.enum(mcpCatalog.map((entry) => entry.id));
+const McpName = z.string().trim().min(1).max(64);
+// https, and on this computer also http://localhost (E57), like a service's MCP address.
+const McpUrl = z
+    .url({ protocol: /^https?$/ })
+    .max(2000)
+    .refine((value) => {
+    const url = new URL(value);
+    // A name and password in the address would be answered with it; a sign-in goes in `value`.
+    if (url.username || url.password)
+        return false;
+    return (url.protocol === "https:" || ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname));
+}, {
+    message: "An MCP address starts with https:// (on this computer also http://localhost) and holds no name or password.",
+});
+// A header's name as HTTP takes it; `authorization` is the bearer token's, `host` the request's own.
+const HeaderName = z
+    .string()
+    .trim()
+    .regex(/^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/, "A header's name holds letters, digits and - only.")
+    .refine((name) => !["host", "content-length", "content-type"].includes(name.toLowerCase()), {
+    message: "This header is the request's own.",
+});
+// The bearer token or the header's value as pasted; never answered.
+const McpValue = z.string().trim().min(1).max(8000);
+export const McpListInput = z.strictObject({
+    cursor: McpId.optional(),
+    limit: Limit.optional(),
+});
+export const McpGetInput = z.strictObject({ mcpId: McpId });
+// "Verbinden": a catalog entry by its id, or one's own with name, address and sign-in. A bearer token
+// and a header take `value`, a header its `headerName` too. The connection is checked at once
+// (`tools/list`); a check that fails saves nothing. OAuth saves the MCP as `pending` with the address
+// the person signs in at (`authorizeUrl`).
+export const McpCreateInput = z
+    .strictObject({
+    catalogId: McpCatalogId.optional().describe("A prepared MCP of the catalog (gmail, calendar, drive, slack, teams, outlook, hubspot, notion). Leave name, url and auth out then."),
+    name: McpName.optional(),
+    url: McpUrl.optional(),
+    auth: McpAuth.optional(),
+    headerName: HeaderName.optional(),
+    value: McpValue.optional().describe("The bearer token or the header's value. Stored sealed for you alone and never shown again."),
+})
+    .refine((input) => input.catalogId !== undefined
+    ? input.name === undefined &&
+        input.url === undefined &&
+        input.auth === undefined &&
+        input.headerName === undefined &&
+        input.value === undefined
+    : input.name !== undefined && input.url !== undefined && input.auth !== undefined, { message: "Name either catalogId, or name, url and auth of your own MCP." })
+    .refine((input) => input.auth === "bearer"
+    ? input.value !== undefined && input.headerName === undefined
+    : input.auth === "header"
+        ? input.value !== undefined && input.headerName !== undefined
+        : input.value === undefined && input.headerName === undefined, {
+    message: "bearer takes value, header takes headerName and value, oauth and none take neither.",
+});
+// The switches of its tools, a new name, a new sign-in ("Neu anmelden": a new `value` for a bearer
+// token or a header, `signIn: true` for OAuth, which answers a new `authorizeUrl`).
+export const McpUpdateInput = z
+    .strictObject({
+    mcpId: McpId,
+    name: McpName.optional(),
+    tools: z
+        .record(z.string().min(1).max(128), z.boolean())
+        .optional()
+        .describe("Tool names to switch on (true) or off (false). An Operator never sees a tool that is off."),
+    value: McpValue.optional(),
+    signIn: z.literal(true).optional(),
+})
+    .refine((input) => input.name !== undefined ||
+    input.tools !== undefined ||
+    input.value !== undefined ||
+    input.signIn !== undefined, { message: "Name a field to change: name, tools, value or signIn." });
+// Checks the connection again (`tools/list`): its state, and the tools the server has now. A new tool
+// that writes comes switched off.
+export const McpTestInput = z.strictObject({ mcpId: McpId });
+// "Trennen": the sign-in is deleted at once and without archive, and no Operator reaches it any more.
+export const McpRevokeInput = z.strictObject({ mcpId: McpId });
+export const McpCallListInput = z.strictObject({
+    mcpId: McpId,
+    cursor: idSchema("call").optional(),
+    limit: Limit.optional(),
+});
+// A tool of the server as its last check listed it: whether it writes (by the server's own
+// `readOnlyHint`; without one it counts as writing) and whether it is switched on.
+export const McpTool = z.object({
+    name: z.string(),
+    description: z.string(),
+    writes: z.boolean(),
+    enabled: z.boolean(),
+});
+export const Mcp = z.object({
+    mcpId: McpId,
+    // The catalog entry it came from; null for one's own.
+    catalogId: McpCatalogId.nullable(),
+    name: z.string(),
+    url: z.string(),
+    auth: McpAuth,
+    // Only for the sign-in by header: its name, never its value.
+    headerName: z.string().nullable(),
+    state: McpState,
+    // While `pending`: where the person signs in, in their browser. Null otherwise.
+    authorizeUrl: z.string().nullable(),
+    // Why the last check did not pass; null when it did.
+    problem: z.string().nullable(),
+    tools: z.array(McpTool),
+    // The person's Operators that may use it (their detail under "MCPs"), deleted ones left out.
+    machineIds: z.array(MachineId),
+    checkedAt: z.iso.datetime().nullable(),
+    createdAt: z.iso.datetime(),
+    createdBy: UserId.nullable(),
+    updatedAt: z.iso.datetime(),
+});
+export const McpList = z.object({ items: z.array(Mcp), nextCursor: McpId.nullable() });
+// The protocol of an MCP (its tab Protokoll): what its person did with it and every call of an
+// Operator through it, newest first. `call` names the tool; `blocked` is a call of a tool that is off,
+// refused before it reached the server.
+export const McpCallAction = z.enum([
+    "connect",
+    "signin",
+    "update",
+    "test",
+    "expire",
+    "revoke",
+    "call",
+    "blocked",
+]);
+export const McpCall = z.object({
+    callId: idSchema("call"),
+    action: McpCallAction,
+    tool: z.string().nullable(),
+    // The Operator that called; null for what its person did.
+    machineId: MachineId.nullable(),
+    // The server's HTTP status for a call; null for the rest.
+    status: z.int().nullable(),
+    createdAt: z.iso.datetime(),
+});
+export const McpCallList = z.object({
+    items: z.array(McpCall),
+    nextCursor: idSchema("call").nullable(),
+});

package/dist/nodes/nodes.d.ts

@@ -7,7 +7,7 @@ export declare const SecretFields: {
     secret: z.ZodOptional<z.ZodLiteral<true>>;
     locked: z.ZodOptional<z.ZodBoolean>;
 };
-export declare const nodeKinds: readonly ["folder", "document", "table", "board", "task", "file", "gadget"];
+export declare const nodeKinds: readonly ["folder", "document", "table", "board", "task", "file", "gadget", "goal", "skill"];
 export declare const NodeKind: z.ZodEnum<{
     file: "file";
     folder: "folder";
@@ -16,6 +16,8 @@ export declare const NodeKind: z.ZodEnum<{
     board: "board";
     task: "task";
     gadget: "gadget";
+    goal: "goal";
+    skill: "skill";
 }>;
 export type NodeKind = z.infer<typeof NodeKind>;
 export declare const responsibleKinds: readonly ["document", "table", "file"];
@@ -97,6 +99,8 @@ export declare const NodeListItem: z.ZodObject<{
         board: "board";
         task: "task";
         gadget: "gadget";
+        goal: "goal";
+        skill: "skill";
     }>;
     name: z.ZodString;
     hidden: z.ZodBoolean;
@@ -166,6 +170,8 @@ export declare const NodeList: z.ZodObject<{
             board: "board";
             task: "task";
             gadget: "gadget";
+            goal: "goal";
+            skill: "skill";
         }>;
         name: z.ZodString;
         hidden: z.ZodBoolean;
@@ -260,6 +266,8 @@ export declare const NodeHit: z.ZodObject<{
         board: "board";
         task: "task";
         gadget: "gadget";
+        goal: "goal";
+        skill: "skill";
     }>;
     name: z.ZodString;
     path: z.ZodObject<{
@@ -330,6 +338,8 @@ export declare const NodeSearch: z.ZodObject<{
             board: "board";
             task: "task";
             gadget: "gadget";
+            goal: "goal";
+            skill: "skill";
         }>;
         name: z.ZodString;
         path: z.ZodObject<{
@@ -459,6 +469,8 @@ export declare const NodeDetail: z.ZodObject<{
         board: "board";
         task: "task";
         gadget: "gadget";
+        goal: "goal";
+        skill: "skill";
     }>;
     name: z.ZodString;
     hidden: z.ZodBoolean;

package/dist/nodes/nodes.js

@@ -35,6 +35,10 @@ export const nodeKinds = [
     "file",
     // #642, E118: a small application with files, a draft and published versions.
     "gadget",
+    // #813, E139: what is to be reached by when; its Operator plans every run itself.
+    "goal",
+    // #817, E140: how something is done well, with its result, trigger and tests.
+    "skill",
 ];
 export const NodeKind = z.enum(nodeKinds);
 // Only these kinds have a responsible person (E32): the one who answers for the content's validity.
@@ -73,7 +77,7 @@ export const NodeListInput = z.strictObject({
     section: NodeSection.optional().describe("List a section of the tree instead of a folder: own (what lies in your own root folder), shared (the tops of everything others let you reach) or users (every other person's root folder, only for an admin in admin mode)."),
     query: NodeQuery.optional(),
     includeHidden: Flag.optional().describe("Also list nodes whose name starts with a dot. Leaving it out hides them."),
-    sort: NodeSort.optional().describe("The order: name (default, A to Z), updated (most recently changed first), kind, or status (the type of the column the validation ticket stands in: backlog, open, progress, done, discarded, blocked, archive, then nodes without a ticket)."),
+    sort: NodeSort.optional().describe("The order: name (default, A to Z), updated (most recently changed first), kind, or status (the type of the column the validation ticket stands in, New read as backlog: backlog, open, progress, done, discarded, blocked, archive, then nodes without a ticket)."),
     foldersFirst: Flag.optional().describe("Put folders before everything else, each group in the chosen order."),
     cursor: z
         .string()
@@ -121,8 +125,8 @@ export const NodeListItem = z.object({
     sharedWith: z.number().int(),
     // When it went into the archive; null for a node that is not archived.
     archivedAt: z.iso.datetime().nullable(),
-    // The validation status (#47): the type of the column its ticket stands in; null for a kind that is
-    // not validated.
+    // The validation status (#47): the type of the column its ticket stands in, a ticket in New read as
+    // `backlog` (unchecked, #814); null for a kind that is not validated.
     status: ColumnType.nullable(),
     // A board that is a system part with a lock (#52: the tree draws the lock and no ⋯); null for
     // every other node.