@anchrd/colab-sdk 0.1.29 → 0.1.31

package/dist/connectors/connectors.js

@@ -1,6 +1,9 @@
 import { z } from "zod";
+import { GadgetFile, GadgetFilePath, GadgetTestRun } from "../gadgets/gadgets.js";
 import { idSchema } from "../ids/ids.js";
 import { Flag, Limit } from "../list-input.js";
+import { NodePerson } from "../nodes/nodes.js";
+import { Rev } from "../primitives/primitives.js";
 // The connectors' catalog and call log (#5): the inputs of `connectors_connector_list`,
 // `connectors_connector_get` and `connectors_call_list` and the answers the UI (#7) reads.
 // The id from a connector's code (`shopify`), never a ULID: one single word (E64).
@@ -10,7 +13,166 @@ export const ConnectorListInput = z.strictObject({
     cursor: ConnectorId.optional(),
     limit: Limit.optional(),
 });
-export const ConnectorGetInput = z.strictObject({ connectorId: ConnectorId });
+// Which state of a built connector (#894): live, the draft, or a published version by its number.
+// Over REST the query string carries text, so digits become the number here.
+export const ConnectorVersionRef = z.preprocess((value) => (typeof value === "string" && /^[1-9][0-9]{0,8}$/.test(value) ? Number(value) : value), z.union([z.enum(["live", "draft"]), z.number().int().min(1)]));
+const ConnectorInclude = z.enum(["files"]);
+export const ConnectorGetInput = z.strictObject({
+    connectorId: ConnectorId,
+    version: ConnectorVersionRef.optional().describe("Which state to read: live (the default; the draft for a connector never published), draft (only with the right to change it) or the number of a published version."),
+    include: z
+        .preprocess((value) => (typeof value === "string" ? value.split(",") : value), z.array(ConnectorInclude).min(1).max(1))
+        .optional()
+        .describe("files: answer the text of every file of that state, not only their paths."),
+});
+// ---- A connector built in Colab (#894, E149, Codebase › Connector-Format) ----
+// The name of a setting or a secret, `GITHUB_APP_ID`: what the connection form and the vault key by.
+export const ConnectorFieldName = z
+    .string()
+    .regex(/^[A-Z][A-Z0-9_]{0,63}$/)
+    .describe("A field's name in capitals, such as SHOP_URL or API_TOKEN.");
+// One field of the connection form in `connector.json`.
+export const ConnectorManifestField = z.strictObject({
+    label: z.string().min(1).max(100),
+    help: z.string().max(1000).optional(),
+    placeholder: z.string().max(200).optional(),
+    // Without it the field is required; with a `default` it is optional anyway.
+    optional: z.boolean().optional(),
+    default: z.string().max(2000).optional(),
+    // Checked when a connection is saved, in Colab: a regular expression the value matches in full.
+    pattern: z.string().max(500).optional(),
+    minLength: z.number().int().min(1).max(10_000).optional(),
+});
+const HeaderName = z.string().regex(/^[A-Za-z0-9-]{1,64}$/);
+const QueryName = z.string().regex(/^[A-Za-z0-9_.-]{1,64}$/);
+// How the bridge sets the credential on every request (#894). The code never sees it.
+export const ConnectorAccess = z.discriminatedUnion("kind", [
+    // `Authorization: Bearer <secret>`.
+    z.strictObject({ kind: z.literal("bearer"), secret: ConnectorFieldName }),
+    // The secret in a header of the provider's choosing, with an optional prefix (`Key `).
+    z.strictObject({
+        kind: z.literal("header"),
+        name: HeaderName,
+        prefix: z.string().max(40).optional(),
+        secret: ConnectorFieldName,
+    }),
+    // HTTP basic: the user name from a setting or a secret, the password a secret.
+    z.strictObject({
+        kind: z.literal("basic"),
+        username: ConnectorFieldName,
+        password: ConnectorFieldName,
+    }),
+    // The secret as a query parameter of every request.
+    z.strictObject({ kind: z.literal("query"), name: QueryName, secret: ConnectorFieldName }),
+    // A GitHub App: the bridge signs the JWT with GITHUB_PRIVATE_KEY and buys an installation token
+    // with GITHUB_APP_ID and GITHUB_INSTALLATION_ID; the base is api.github.com.
+    z.strictObject({ kind: z.literal("githubApp") }),
+    z.strictObject({ kind: z.literal("none") }),
+]);
+export const connectorAccessKinds = [
+    "bearer",
+    "header",
+    "basic",
+    "query",
+    "githubApp",
+    "none",
+];
+export const ConnectorManifestTool = z.strictObject({
+    description: z.string().min(1).max(4000),
+    writes: z.boolean(),
+    // A JSON Schema of an object without further keys (`additionalProperties: false`).
+    input: z.record(z.string(), z.unknown()),
+});
+// `connector.json`. Strict although it is a file: a misspelt key must be refused, not dropped.
+export const ConnectorManifest = z.strictObject({
+    id: ConnectorId,
+    name: z.string().min(1).max(100),
+    category: z.string().min(1).max(50),
+    description: z.string().max(500),
+    // Every request's address starts here; `{{settings.NAME}}` puts in a setting.
+    base: z.string().min(1).max(500),
+    // The only hosts the bridge lets a request reach: a host name, or `{{settings.NAME}}` for the host
+    // of a setting's address.
+    hosts: z.array(z.string().min(1).max(300)).min(1).max(20),
+    access: ConnectorAccess,
+    settings: z.record(ConnectorFieldName, ConnectorManifestField).optional(),
+    secrets: z.record(ConnectorFieldName, ConnectorManifestField).optional(),
+    // Keyed by `<resource>-<action>` (`invoice-list`); the code exports `invoiceList`.
+    tools: z.record(z.string(), ConnectorManifestTool).optional(),
+});
+export const connectorManifestPath = "connector.json";
+export const connectorCodePath = "connector.js";
+// The person behind a draft or a version, as `access` names them.
+const ConnectorPerson = NodePerson;
+const ConnectorFiles = z
+    .record(GadgetFilePath, z.string().describe("The file's whole text."))
+    .describe("Files by path: connector.json, connector.js, tests/*.test.js, tests/fixtures/*, icon.svg.");
+export const ConnectorCreateInput = z.strictObject({
+    connectorId: ConnectorId.describe("One lowercase word, the first word of every tool, such as lexoffice. It cannot change later."),
+    name: z.string().trim().min(1).max(100),
+    description: z.string().trim().max(500),
+    category: z.string().trim().min(1).max(50),
+    base: z
+        .string()
+        .trim()
+        .min(1)
+        .max(500)
+        .describe("The API's address, such as https://api.lexoffice.io/v1; only its host is reachable."),
+    access: z
+        .enum(connectorAccessKinds)
+        .describe("How the credential is sent: bearer, header, basic, query, githubApp or none."),
+    icon: z
+        .string()
+        .max(200_000)
+        .optional()
+        .describe("The logo as SVG text or as a data: URL of a PNG."),
+    files: ConnectorFiles.optional().describe("Further first files of the draft. A connector.json among them replaces the one made from the fields above."),
+});
+export const ConnectorUpdateInput = z.strictObject({
+    connectorId: ConnectorId,
+    files: z
+        .record(GadgetFilePath, z.string().nullable())
+        .optional()
+        .describe("Files to write into the draft by path, each with its whole new text; null removes a file. Files you leave out stay. Without a draft, the draft starts from the live version."),
+    fromVersion: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe("Restore: the draft becomes the files of this published version."),
+    discard: z.literal(true).optional().describe("Throw the draft away; live stays as it is."),
+    rev: Rev,
+});
+export const ConnectorTestInput = z.strictObject({
+    connectorId: ConnectorId,
+    version: z
+        .enum(["live", "draft"])
+        .optional()
+        .describe("Which state: draft (the default when there is one) or live."),
+    connection: z
+        .literal(true)
+        .optional()
+        .describe("Run the connection test test() against the provider, with the company's connection."),
+    function: z
+        .string()
+        .max(100)
+        .optional()
+        .describe("Run one tool, by its function such as invoice-list, against the provider with the company's connection; its input in input."),
+    input: z.record(z.string(), z.unknown()).optional(),
+});
+export const ConnectorPublishInput = z.strictObject({
+    connectorId: ConnectorId,
+    force: z.literal(true).optional().describe("Publish although the draft's tests fail."),
+    rev: Rev,
+});
+export const ConnectorArchiveInput = z.strictObject({ connectorId: ConnectorId, rev: Rev });
+export const ConnectorRestoreInput = z.strictObject({ connectorId: ConnectorId, rev: Rev });
+export const ConnectorChange = z.object({
+    path: z.string(),
+    change: z.enum(["added", "changed", "removed"]),
+});
+// One run of a connector's tests (#894): the same shape as a gadget's.
+export const ConnectorTestRun = GadgetTestRun;
 // One field of the form a connection is entered in (#7), from the connector's `settings` and
 // `secrets` and their `.meta()`. A `secret` field is a password field and is never read back.
 //
@@ -36,13 +198,73 @@ export const Connector = z.object({
     name: z.string(),
     category: z.string(),
     description: z.string(),
-    // The SVG as text, for the catalog tile.
+    // The SVG as text, or a data: URL of a PNG (#894), for the catalog tile.
     icon: z.string(),
-    // From the catalog `anchrd/connectors`, rather than the installation's own.
+    // From the catalog `anchrd/connectors`, rather than the installation's own. Always false since
+    // #894: every connector is built in the installation.
     catalog: z.boolean(),
+    // Of the live version; of the draft for a connector never published.
     tools: z.array(ConnectorTool),
     fields: z.array(ConnectorField),
+    // The hosts the bridge lets it reach, and how the credential is sent (#894).
+    hosts: z.array(z.string()),
+    access: z.string(),
+    live: z
+        .object({
+        version: z.number().int(),
+        publishedAt: z.iso.datetime(),
+        publishedBy: ConnectorPerson.nullable(),
+    })
+        .nullable(),
+    // Only for whoever may change the connector; null without a draft and for everybody else.
+    draft: z
+        .object({
+        // The number the draft gets when it is published.
+        version: z.number().int(),
+        updatedAt: z.iso.datetime(),
+        updatedBy: ConnectorPerson.nullable(),
+        changes: z.array(ConnectorChange),
+        // Tools and hosts the draft has and live has not: what a publish adds.
+        newTools: z.array(ConnectorTool),
+        newHosts: z.array(z.string()),
+        tools: z.number().int(),
+    })
+        .nullable(),
+    archivedAt: z.iso.datetime().nullable(),
+    // The state the next save sends (E70).
+    rev: z.number().int(),
+});
+// `connectors_connector_get` (#894): the catalog entry, and the files of one state with its tests and
+// versions.
+export const ConnectorDetail = Connector.extend({
+    // The state the files belong to: a version's number, `draft`, or null without either.
+    version: z.union([z.number().int(), z.literal("draft")]).nullable(),
+    manifest: ConnectorManifest.nullable(),
+    files: z.array(GadgetFile),
+    // The last run of the tests; null before the first and for whoever may not change the connector.
+    test: ConnectorTestRun.nullable(),
+    // Every published version, newest first, with the calls and errors of the last 7 days.
+    versions: z.array(z.object({
+        version: z.number().int(),
+        createdAt: z.iso.datetime(),
+        createdBy: ConnectorPerson.nullable(),
+        calls: z.number().int(),
+        errors: z.number().int(),
+    })),
+    rights: z.object({ update: z.boolean(), publish: z.boolean() }),
 });
+// What `connectors_connector_test` answers (#894): the tests, the connection test, or one tool's call.
+export const ConnectorTestAnswer = z.union([
+    z.object({ tests: ConnectorTestRun }),
+    z.object({
+        connection: z.object({
+            ok: z.boolean(),
+            detail: z.string().nullable(),
+            message: z.string().nullable(),
+        }),
+    }),
+    z.object({ output: z.unknown() }),
+]);
 export const ConnectorList = z.object({
     items: z.array(Connector),
     nextCursor: ConnectorId.nullable(),
@@ -67,6 +289,11 @@ export const Call = z.object({
     // The provider's HTTP status, 200 on success, null without an answer.
     status: z.number().int().nullable(),
     failed: z.boolean(),
+    // How it failed (#894): `rejected`, `unauthorized`, `unavailable`, or `host` when the bridge refused
+    // a request to a host the connector does not name. Null when it did not fail, and before #894.
+    failure: z.string().nullable(),
+    // The state that ran (#894): `draft` or a published version; null before #894.
+    version: z.union([z.number().int(), z.literal("draft")]).nullable(),
     durationMs: z.number().int(),
     createdAt: z.iso.datetime(),
     // Null for the daily test, which nobody started. Name, kind and picture come from `access`, null

package/dist/crawls/crawls.d.ts

@@ -35,9 +35,9 @@ export declare const CrawlGetInput: z.ZodObject<{
 export type CrawlGetInput = z.infer<typeof CrawlGetInput>;
 export declare const CrawlStatus: z.ZodEnum<{
     done: "done";
-    failed: "failed";
     expired: "expired";
     running: "running";
+    failed: "failed";
     starting: "starting";
     reading: "reading";
 }>;
@@ -47,9 +47,9 @@ export declare const Crawl: z.ZodObject<{
     url: z.ZodString;
     status: z.ZodEnum<{
         done: "done";
-        failed: "failed";
         expired: "expired";
         running: "running";
+        failed: "failed";
         starting: "starting";
         reading: "reading";
     }>;
@@ -92,9 +92,9 @@ export declare const CrawlDetail: z.ZodObject<{
         url: z.ZodString;
         status: z.ZodEnum<{
             done: "done";
-            failed: "failed";
             expired: "expired";
             running: "running";
+            failed: "failed";
             starting: "starting";
             reading: "reading";
         }>;

package/dist/error/error.d.ts

@@ -23,6 +23,7 @@ export declare const ErrorCurrent: z.ZodObject<{
     gadgetId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     nodeId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
     machineId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+    connectorId: z.ZodOptional<z.ZodString>;
     rev: z.ZodNumber;
     savedBy: z.ZodOptional<z.ZodObject<{
         userId: z.ZodString;
@@ -58,6 +59,7 @@ export declare const ErrorResponse: z.ZodObject<{
             gadgetId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
             nodeId: z.ZodOptional<z.ZodTemplateLiteral<`node_${string}`>>;
             machineId: z.ZodOptional<z.ZodTemplateLiteral<`user_${string}`>>;
+            connectorId: z.ZodOptional<z.ZodString>;
             rev: z.ZodNumber;
             savedBy: z.ZodOptional<z.ZodObject<{
                 userId: z.ZodString;

package/dist/error/error.js

@@ -34,6 +34,8 @@ export const ErrorCurrent = z.strictObject({
     gadgetId: NodeRef.optional(),
     nodeId: NodeRef.optional(),
     machineId: idSchema("user").optional(),
+    // A built connector's id (#894), `github`.
+    connectorId: z.string().optional(),
     rev: z.number().int(),
     savedBy: z.strictObject({ userId: z.string(), name: z.string() }).optional(),
     savedAt: z.iso.datetime(),

package/dist/gadgets/gadgets.d.ts

@@ -82,15 +82,15 @@ export declare const GadgetTestInput: z.ZodObject<{
 }, z.core.$strict>;
 export type GadgetTestInput = z.infer<typeof GadgetTestInput>;
 export declare const GadgetCallStatus: z.ZodEnum<{
-    failed: "failed";
     succeeded: "succeeded";
+    failed: "failed";
 }>;
 export type GadgetCallStatus = z.infer<typeof GadgetCallStatus>;
 export declare const GadgetCallListInput: z.ZodObject<{
     gadgetId: z.ZodTemplateLiteral<`node_${string}`>;
     status: z.ZodOptional<z.ZodEnum<{
-        failed: "failed";
         succeeded: "succeeded";
+        failed: "failed";
     }>>;
     version: z.ZodOptional<z.ZodPreprocess<z.ZodUnion<readonly [z.ZodEnum<{
         live: "live";
@@ -193,8 +193,8 @@ export declare const GadgetTestRun: z.ZodObject<{
     version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
     current: z.ZodBoolean;
     status: z.ZodEnum<{
-        failed: "failed";
         running: "running";
+        failed: "failed";
         passed: "passed";
     }>;
     passed: z.ZodNumber;
@@ -297,8 +297,8 @@ export declare const GadgetDetail: z.ZodObject<{
         version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
         current: z.ZodBoolean;
         status: z.ZodEnum<{
-            failed: "failed";
             running: "running";
+            failed: "failed";
             passed: "passed";
         }>;
         passed: z.ZodNumber;
@@ -391,8 +391,8 @@ export declare const GadgetCall: z.ZodObject<{
     function: z.ZodString;
     version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
     status: z.ZodEnum<{
-        failed: "failed";
         succeeded: "succeeded";
+        failed: "failed";
     }>;
     output: z.ZodUnknown;
     error: z.ZodNullable<z.ZodObject<{
@@ -442,8 +442,8 @@ export declare const GadgetCallItem: z.ZodObject<{
     function: z.ZodNullable<z.ZodString>;
     version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
     status: z.ZodEnum<{
-        failed: "failed";
         succeeded: "succeeded";
+        failed: "failed";
     }>;
     unavailable: z.ZodBoolean;
     durationMs: z.ZodNullable<z.ZodNumber>;
@@ -470,8 +470,8 @@ export declare const GadgetCallList: z.ZodObject<{
         function: z.ZodNullable<z.ZodString>;
         version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
         status: z.ZodEnum<{
-            failed: "failed";
             succeeded: "succeeded";
+            failed: "failed";
         }>;
         unavailable: z.ZodBoolean;
         durationMs: z.ZodNullable<z.ZodNumber>;
@@ -499,8 +499,8 @@ export declare const GadgetCallEntry: z.ZodObject<{
     function: z.ZodNullable<z.ZodString>;
     version: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"draft">]>;
     status: z.ZodEnum<{
-        failed: "failed";
         succeeded: "succeeded";
+        failed: "failed";
     }>;
     unavailable: z.ZodBoolean;
     durationMs: z.ZodNullable<z.ZodNumber>;

package/dist/gadgets/gadgets.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { CallId } from "../connectors/connectors.js";
 import { ErrorCode } from "../error/error.js";
+import { idSchema } from "../ids/ids.js";
 import { Limit } from "../list-input.js";
 import { NodeId, NodePath, NodePerson } from "../nodes/nodes.js";
 import { IdempotencyKey, Rev } from "../primitives/primitives.js";
@@ -11,7 +11,8 @@ import { UserId } from "../users/users.js";
 // `intelligence_gadget_call_create`, and their answers.
 const GadgetId = NodeId.describe("The gadget's id, a `node_…` of kind gadget.");
 // One entry of a gadget's log (#643), `call_…` like a connector's call (the resource `call`).
-const GadgetCallId = CallId.describe("An entry of the gadget's log, `call_…`.");
+// ⚠️ Not `CallId` of `connectors.ts`: that module imports this one (#894).
+const GadgetCallId = idSchema("call").describe("An entry of the gadget's log, `call_…`.");
 // A file's path inside the gadget: `server.js`, `lib/format.js`, `tests/status.test.js`. Segments of
 // letters, digits, `_`, `-` and `.`, none starting with a dot, so `..` and hidden files cannot exist
 // and `.colab/` stays Colab's own (the runtime's harness lives there).

package/dist/goals/goals.d.ts

@@ -149,6 +149,7 @@ export declare const GoalCheck: z.ZodObject<{
         gadget: "gadget";
         goal: "goal";
         skill: "skill";
+        source: "source";
     }>>;
     needs: z.ZodNullable<z.ZodEnum<{
         write: "write";
@@ -219,6 +220,7 @@ export declare const GoalReady: z.ZodObject<{
             gadget: "gadget";
             goal: "goal";
             skill: "skill";
+            source: "source";
         }>>;
         needs: z.ZodNullable<z.ZodEnum<{
             write: "write";
@@ -739,6 +741,7 @@ export declare const GoalDetail: z.ZodObject<{
                 gadget: "gadget";
                 goal: "goal";
                 skill: "skill";
+                source: "source";
             }>>;
             needs: z.ZodNullable<z.ZodEnum<{
                 write: "write";

package/dist/grammar/grammar.d.ts

@@ -37,6 +37,9 @@ export declare const resources: {
     readonly step: "steps";
     readonly crawl: "crawls";
     readonly mcp: "mcps";
+    readonly source: "sources";
+    readonly query: "queries";
+    readonly item: "items";
 };
 export declare const actions: readonly ["list", "get", "create", "update", "archive", "restore", "purge"];
 export declare const verbs: readonly ["invite", "resend", "disable", "enable", "rotate", "share", "move", "start", "complete", "test", "revoke", "remove", "unlock", "publish", "schedule", "unpublish", "cancel"];

package/dist/grammar/grammar.js

@@ -72,6 +72,12 @@ export const resources = {
     // A person's own MCP server for their personal Operators (#802, E144, Einstellungen › MCPs):
     // `operator_mcp_*`, its protocol `operator_mcp_call_list`. Named by the ticket and the page.
     mcp: "mcps",
+    // A node that fetches data from outside on a schedule and keeps it (#900, E151, Nodes › Quelle):
+    // `intelligence_source_*`; what it fetches is a query (`intelligence_source_query_*`), what it
+    // keeps an item (`intelligence_source_item_list`). Named by the ticket.
+    source: "sources",
+    query: "queries",
+    item: "items",
 };
 // The closed list of actions with a route of their own shape.
 export const actions = ["list", "get", "create", "update", "archive", "restore", "purge"];

package/dist/mcps/mcps.d.ts

@@ -2,10 +2,10 @@ import { z } from "zod";
 export declare const McpId: z.ZodTemplateLiteral<`mcp_${string}`>;
 export type McpId = z.infer<typeof McpId>;
 export declare const McpAuth: z.ZodEnum<{
-    oauth: "oauth";
     bearer: "bearer";
     header: "header";
     none: "none";
+    oauth: "oauth";
 }>;
 export type McpAuth = z.infer<typeof McpAuth>;
 export declare const McpState: z.ZodEnum<{
@@ -190,10 +190,10 @@ export declare const McpCreateInput: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     url: z.ZodOptional<z.ZodURL>;
     auth: z.ZodOptional<z.ZodEnum<{
-        oauth: "oauth";
         bearer: "bearer";
         header: "header";
         none: "none";
+        oauth: "oauth";
     }>>;
     headerName: z.ZodOptional<z.ZodString>;
     value: z.ZodOptional<z.ZodString>;
@@ -236,10 +236,10 @@ export declare const Mcp: z.ZodObject<{
     name: z.ZodString;
     url: z.ZodString;
     auth: z.ZodEnum<{
-        oauth: "oauth";
         bearer: "bearer";
         header: "header";
         none: "none";
+        oauth: "oauth";
     }>;
     headerName: z.ZodNullable<z.ZodString>;
     state: z.ZodEnum<{
@@ -272,10 +272,10 @@ export declare const McpList: z.ZodObject<{
         name: z.ZodString;
         url: z.ZodString;
         auth: z.ZodEnum<{
-            oauth: "oauth";
             bearer: "bearer";
             header: "header";
             none: "none";
+            oauth: "oauth";
         }>;
         headerName: z.ZodNullable<z.ZodString>;
         state: z.ZodEnum<{

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", "goal", "skill"];
+export declare const nodeKinds: readonly ["folder", "document", "table", "board", "task", "file", "gadget", "goal", "skill", "source"];
 export declare const NodeKind: z.ZodEnum<{
     file: "file";
     folder: "folder";
@@ -18,6 +18,7 @@ export declare const NodeKind: z.ZodEnum<{
     gadget: "gadget";
     goal: "goal";
     skill: "skill";
+    source: "source";
 }>;
 export type NodeKind = z.infer<typeof NodeKind>;
 export declare const responsibleKinds: readonly ["document", "table", "file"];
@@ -39,8 +40,8 @@ export declare const NodeSection: z.ZodEnum<{
 export type NodeSection = z.infer<typeof NodeSection>;
 export declare const NodeSort: z.ZodEnum<{
     name: "name";
-    kind: "kind";
     status: "status";
+    kind: "kind";
     updated: "updated";
 }>;
 export type NodeSort = z.infer<typeof NodeSort>;
@@ -56,8 +57,8 @@ export declare const NodeListInput: z.ZodObject<{
     includeHidden: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
     sort: z.ZodOptional<z.ZodEnum<{
         name: "name";
-        kind: "kind";
         status: "status";
+        kind: "kind";
         updated: "updated";
     }>>;
     foldersFirst: z.ZodOptional<z.ZodPreprocess<z.ZodBoolean, unknown>>;
@@ -101,6 +102,7 @@ export declare const NodeListItem: z.ZodObject<{
         gadget: "gadget";
         goal: "goal";
         skill: "skill";
+        source: "source";
     }>;
     name: z.ZodString;
     hidden: z.ZodBoolean;
@@ -172,6 +174,7 @@ export declare const NodeList: z.ZodObject<{
             gadget: "gadget";
             goal: "goal";
             skill: "skill";
+            source: "source";
         }>;
         name: z.ZodString;
         hidden: z.ZodBoolean;
@@ -268,6 +271,7 @@ export declare const NodeHit: z.ZodObject<{
         gadget: "gadget";
         goal: "goal";
         skill: "skill";
+        source: "source";
     }>;
     name: z.ZodString;
     path: z.ZodObject<{
@@ -340,6 +344,7 @@ export declare const NodeSearch: z.ZodObject<{
             gadget: "gadget";
             goal: "goal";
             skill: "skill";
+            source: "source";
         }>;
         name: z.ZodString;
         path: z.ZodObject<{
@@ -471,6 +476,7 @@ export declare const NodeDetail: z.ZodObject<{
         gadget: "gadget";
         goal: "goal";
         skill: "skill";
+        source: "source";
     }>;
     name: z.ZodString;
     hidden: z.ZodBoolean;

package/dist/nodes/nodes.js

@@ -39,6 +39,8 @@ export const nodeKinds = [
     "goal",
     // #817, E140: how something is done well, with its result, trigger and tests.
     "skill",
+    // #900, E151: fetches data from outside on a schedule and keeps it as items.
+    "source",
 ];
 export const NodeKind = z.enum(nodeKinds);
 // Only these kinds have a responsible person (E32): the one who answers for the content's validity.

package/dist/operators/operators.d.ts

@@ -937,8 +937,8 @@ export type OperatorUserList = z.infer<typeof OperatorUserList>;
 export declare const OperatorRunId: z.ZodTemplateLiteral<`run_${string}`>;
 export type OperatorRunId = z.infer<typeof OperatorRunId>;
 export declare const OperatorRunStatus: z.ZodEnum<{
-    failed: "failed";
     running: "running";
+    failed: "failed";
     completed: "completed";
     stopped: "stopped";
 }>;
@@ -1006,8 +1006,8 @@ export declare const OperatorRun: z.ZodObject<{
         retry: "retry";
     }>;
     status: z.ZodEnum<{
-        failed: "failed";
         running: "running";
+        failed: "failed";
         completed: "completed";
         stopped: "stopped";
     }>;
@@ -1088,8 +1088,8 @@ export declare const OperatorRunListInput: z.ZodObject<{
         gemini: "gemini";
     }>>;
     status: z.ZodOptional<z.ZodEnum<{
-        failed: "failed";
         running: "running";
+        failed: "failed";
         completed: "completed";
         stopped: "stopped";
     }>>;
@@ -1275,8 +1275,8 @@ export declare const OperatorRunList: z.ZodObject<{
             retry: "retry";
         }>;
         status: z.ZodEnum<{
-            failed: "failed";
             running: "running";
+            failed: "failed";
             completed: "completed";
             stopped: "stopped";
         }>;