@anchrd/intel-api 0.14.0 → 0.16.0

package/dist/bundle/bundle.js

@@ -1,6 +1,8 @@
-import { AgentDefinition, AgentMediaType, BlockNoteMediaType, BoardDocument, BoardMediaType, BundleImportResult, BundleManifest, BundleManifestFilename, DocumentLinkInlineType, FlowGraph, TableMediaType, } from "@anchrd/intel-contract";
+import { BundleImportResult, BundleManifest, BundleManifestFilename, } from "@anchrd/intel-contract/bundle";
+import { FlowGraph } from "@anchrd/intel-contract/flow";
+import { BlockNoteMediaType, DocumentLinkInlineType, } from "@anchrd/intel-contract/node";
+import { TableMediaType } from "@anchrd/intel-contract/table";
 import { Unzip, UnzipInflate, Zip, ZipDeflate, ZipPassThrough } from "fflate";
-import { repeatedBoardId, upgradeStoredBoard } from "../nodes/board/board.js";
 import { documentLinkTargets } from "../nodes/document-links/document-links.js";
 import { parseCsv } from "../shared/csv/csv.js";
 import { IntelError } from "../shared/intel-error/intel-error.js";
@@ -217,13 +219,11 @@ function nakedKindOf(name) {
     if (lower.endsWith(".csv")) {
         return { kind: "table", mediaType: TableMediaType, title: name.slice(0, -4) };
     }
-    // ⚠️ Before any plain `.json` rule and with a compound suffix on purpose (#285). A board is not
-    // recognisable from `.json` alone — an agent definition wears the same extension — so the export
-    // writes `.board.json` and a naked upload has to spell it out too. A file that only says `.json`
-    // is an attachment, which is what it was before boards existed.
-    if (lower.endsWith(".board.json")) {
-        return { kind: "board", mediaType: BoardMediaType, title: name.slice(0, -11) };
-    }
+    // ⚠️ `.board.json` had its own rule here until #390 and deliberately does not any more. This is
+    // the NAKED-folder path — a directory somebody picked, with no manifest — so a file called
+    // `plan.board.json` is a JSON file on a disk, and keeping it as an attachment preserves it. A
+    // real export is a different matter: its manifest declares the kind, and that is where such an
+    // entry is refused by name.
     return { kind: "attachment", mediaType: guessedMediaType(lower), title: name };
 }
 const KnownMediaTypes = {
@@ -402,41 +402,11 @@ export function createBundle(deps) {
                 },
             };
         }
-        // A board is one JSON file, exactly like an agent's definition: the document IS the board, so
-        // there is nothing to serialize differently for an export (#285). A board with no version yet
-        // exports as an empty file, the same way an agent without a definition does.
-        if (node.kind === "board") {
-            const path = `${directory}${uniqueName(used, base, ".board.json")}`;
-            return {
-                manifest: {
-                    id: node.id,
-                    kind: "board",
-                    title: node.title,
-                    description: node.description,
-                    mediaType: version?.mediaType ?? BoardMediaType,
-                    path,
-                },
-                content: version === null
-                    ? { type: "text", load: async () => "" }
-                    : { type: "text", load: textLoader(version.contentKey) },
-            };
-        }
-        if (node.kind === "agent") {
-            const path = `${directory}${uniqueName(used, base, ".json")}`;
-            return {
-                manifest: {
-                    id: node.id,
-                    kind: "agent",
-                    title: node.title,
-                    description: node.description,
-                    mediaType: version?.mediaType ?? "application/json",
-                    path,
-                },
-                content: version === null
-                    ? { type: "text", load: async () => "" }
-                    : { type: "text", load: textLoader(version.contentKey) },
-            };
-        }
+        // ⚠️ A row of a kind this build no longer makes — an `agent` or a `board` written before #390
+        // — falls through to the document branch and travels as its raw body. Deliberately forgiving:
+        // refusing here would make one leftover row enough to stop a whole subtree from being exported,
+        // and the file it produces is exactly the bytes that were stored. The IMPORT is where such a
+        // bundle is turned away, by name.
         // A document: markdown stays `.md`, a BlockNote body is JSON and says so with its name.
         const mediaType = version?.mediaType ?? "text/markdown";
         const extension = mediaType === BlockNoteMediaType ? ".json" : ".md";
@@ -945,103 +915,23 @@ export function createBundle(deps) {
                         version = versionRowFor(entry, text, TableMediaType, await deps.hash(text), "snapshot");
                     }
                 }
-                else if (entry.kind === "board") {
-                    const text = entry.body === null ? "" : decodeText(entry.body, entry.path);
-                    if (text.trim().length > 0) {
-                        let document;
-                        try {
-                            // Same upgrade the stored read does (anchrd/intel#311): a bundle exported before
-                            // `terminal` existed is exactly an old board in a file, and importing it must not be
-                            // the one way to lose a board.
-                            document = BoardDocument.parse(upgradeStoredBoard(JSON.parse(text)));
-                        }
-                        catch {
-                            throw new IntelError(400, "import_invalid_board", `Bundle entry is not a board: ${entry.path}`);
-                        }
-                        /**
-                         * ⚠️ Refused by name, and refused rather than folded (anchrd/intel#321).
-                         *
-                         * A board arriving in a file is the ONE place a document somebody else wrote becomes
-                         * truth here — everywhere else a task id is minted by `deps.id()` and a status list
-                         * goes through `ConfigureBoardInput`, which has demanded distinct ids since #285. Two
-                         * tasks under one id threw `graph.addNode` out of the board's graph view, and two
-                         * statuses under one id drew the same cards in two lanes with a drop that had two
-                         * targets meaning one.
-                         *
-                         * Outside the catch above on purpose: swallowed into `import_invalid_board` this would
-                         * read as "that file is not a board", and whoever is holding the file would look for
-                         * the wrong thing. `repeatedBoardId` names the id, which is the line they have to fix.
-                         *
-                         * ⚠️ And it names the way out, not only the fault (anchrd/intel#341). The usual holder
-                         * of such a file is not its author but somebody moving a tree between installations,
-                         * and the pair is in the BOARD the export came from — where `board_repair_task_ids`
-                         * and `board_configure` each remove one kind of it. Told only what is wrong, they were
-                         * left editing JSON by hand or leaving the board behind, and an import is all or
-                         * nothing: one such board stops the whole move.
-                         */
-                        const repeated = repeatedBoardId(document);
-                        if (repeated !== null) {
-                            throw new IntelError(400, "import_duplicate_board_id", repeated.list === "tasks"
-                                ? `Bundle entry names the task “${repeated.id}” twice: ${entry.path}. Repair that board with board_repair_task_ids where it came from, then export it again.`
-                                : `Bundle entry names the status “${repeated.id}” twice: ${entry.path}. Repair that board with board_configure — the status list written whole, with distinct ids — where it came from, then export it again.`);
-                        }
-                        // ⚠️ `references` are remapped the way a document's inline links are, and `dependsOn`
-                        // and `parentId` are NOT (#285). A task's references point at NODES, which the import
-                        // renumbers; its dependencies and its parent point at tasks inside this very file,
-                        // whose ids the import does not touch. Renumbering those would break every edge in the
-                        // board for no reason.
-                        const remapped = {
-                            statuses: document.statuses,
-                            tasks: document.tasks.map((task) => ({
-                                ...task,
-                                references: task.references.map((reference) => idMap.get(reference) ?? reference),
-                            })),
-                        };
-                        const body = JSON.stringify(remapped);
-                        version = versionRowFor(entry, body, BoardMediaType, await deps.hash(body), null);
-                        // Into the same link pass as an imported document: a board's references are `text`
-                        // links, so they have to survive the import the same way.
-                        documentBodies.set(entry.newId, { mediaType: BoardMediaType, content: body });
-                    }
-                }
-                else if (entry.kind === "agent") {
-                    const text = entry.body === null ? "" : decodeText(entry.body, entry.path);
-                    if (text.trim().length > 0) {
-                        let definition;
-                        try {
-                            definition = AgentDefinition.parse(JSON.parse(text));
-                        }
-                        catch {
-                            throw new IntelError(400, "import_invalid_agent", `Bundle entry is not an agent definition: ${entry.path}`);
-                        }
-                        const remapped = {
-                            ...definition,
-                            /**
-                             * ⚠️ A delegation NEVER travels in a file (#208, D30). `tools.delegatedBy` names
-                             * whose portal connection an agent acts on, and the only thing that may write it is
-                             * a person saving the agent in a session Intel authorized — the save path proves
-                             * they reach every named server first. A bundle is a document somebody hands over;
-                             * carrying the field through would let a crafted file name a local user and hand an
-                             * imported agent that person's connection, with no act of theirs anywhere.
-                             *
-                             * The consequence is deliberate and mild: an imported agent arrives with no tools,
-                             * and whoever wants it to have some gives them in the profile — which is the same
-                             * act D30 made the only way in.
-                             */
-                            tools: null,
-                            references: definition.references.map((reference) => idMap.has(reference.nodeId)
-                                ? { ...reference, nodeId: idMap.get(reference.nodeId) }
-                                : reference),
-                            schedules: definition.schedules.map((schedule) => idMap.has(schedule.target.id)
-                                ? {
-                                    ...schedule,
-                                    target: { ...schedule.target, id: idMap.get(schedule.target.id) },
-                                }
-                                : schedule),
-                        };
-                        const body = JSON.stringify(remapped);
-                        version = versionRowFor(entry, body, AgentMediaType, await deps.hash(body), null);
-                    }
+                else if (entry.kind === "board" || entry.kind === "agent") {
+                    /**
+                     * ⚠️ Refused by name, and the name says WHY rather than what the parser tripped over.
+                     *
+                     * Agents and Boards were parked with #385; nothing in this build can hold either kind.
+                     * A bundle that carries one is not malformed — it is a correct export of an installation
+                     * that still had the feature, and the person holding it is usually moving a tree between
+                     * two installations rather than the author of the file. Left to the schema they would get
+                     * `unexpected enum value`, look for a broken file, and find nothing wrong with it.
+                     *
+                     * The refusal names the entry, the kind and the branch the feature is parked on, so the
+                     * answer to "where did my board go" is in the message and not in somebody's memory.
+                     *
+                     * ⚠️ Only a MANIFEST can reach this, because only a manifest declares a kind. A naked
+                     * folder holding a `plan.board.json` imports it as an attachment — see `kindOfFile`.
+                     */
+                    throw new IntelError(400, "import_kind_parked", `Bundle entry “${entry.path}” is a ${entry.kind}, and ${entry.kind}s are not part of this installation any more (anchrd/intel#385). The bundle was exported from a version that still had them; the code is on the branch parked/agents-and-board. Remove the entry from the bundle to import the rest.`);
                 }
                 else if (entry.kind === "attachment") {
                     const bytes = entry.body ?? new Uint8Array(0);

package/dist/bundle/bundle.types.d.ts

@@ -1,4 +1,4 @@
-import type { BundleImportResult, BundleManifest } from "@anchrd/intel-contract";
+import type { BundleImportResult, BundleManifest } from "@anchrd/intel-contract/bundle";
 import type { FlowRepository } from "../flows/flows.types.js";
 import type { Actor, ContentStore, NodeRepository } from "../nodes/nodes.types.js";
 export interface BundleActor extends Actor {

package/dist/cli/cli.js

@@ -2,7 +2,20 @@ import { createBuild } from "../build/build.js";
 import { createPrepare } from "../prepare/prepare.js";
 const interfaces = [
     { handle: "intel", functions: ["use", "admin"] },
-    { handle: "knowledge", functions: ["read", "create", "write", "share"] },
+    // ⚠️ `nodes`, not `knowledge` — and the rename cost something, which is why it needed its own
+    // ticket (#152) five months after #125 renamed everything else. This handle is only half Intel's:
+    // `bootstrap` DECLARES it in Gate and deliberately changes no grant, so to Gate a renamed handle
+    // is a NEW one. Every grant on the old name keeps pointing at the old name, and everybody loses
+    // access at once, silently, until an operator hands the permissions out again.
+    //
+    // It was done in the one window where that is free: the installation on anchrd.sh was being
+    // rebuilt anyway (#385, anchrd/core#93) and there is no other. Doing it later would mean doing it
+    // to somebody.
+    //
+    // ⚠️ The old `knowledge` interface stays declared in Gate — bootstrap declares, it never revokes.
+    // It is a harmless leftover on installations that have it, and nothing in Intel asks about it any
+    // more; removing it is an act in Gate, by hand, when somebody is sure nothing else uses it.
+    { handle: "nodes", functions: ["read", "create", "write", "share"] },
     // ⚠️ No `approve`. The approval node is gone (#73), and this list is what Intel declares to Gate:
     // a function nobody asks about is a permission an operator has to decide on for no reason. An
     // installation that already granted it keeps a harmless leftover — bootstrap declares, it does
@@ -12,15 +25,9 @@ const interfaces = [
         functions: ["read", "create", "write", "publish", "run", "share"],
     },
     { handle: "tools", functions: ["read", "test", "execute", "admin"] },
-    // Declared here, and not by a service of its own, because Gate scopes the rules it returns to the
-    // service whose key asked (least privilege). The agent runtime authorizes its callers with this
-    // installation's Gate service key against the same audience Intel uses, so a handle registered
-    // anywhere else would never appear in the rules that `can("agents", "run")` reads.
-    //
-    // Without it there is no state between "administrator" and "not at all": the runtime falls back to
-    // `intel:admin`, which is the first-grant exit in the same sense as everywhere else, not the way a
-    // team lets a colleague talk to an agent.
-    { handle: "agents", functions: ["run"] },
+    // ⚠️ `agents:run` is deliberately NOT here any more (#390). `bootstrap` declares, it never
+    // revokes, so an installation that has the interface keeps it as a harmless leftover — but a new
+    // one is not asked to decide about a permission nothing reads.
     // `mcp:connect` means the same thing at every MCP service of this installation. A separate name
     // for the same thing forces the operator to check, service by service, which permission carries
     // portal access.
@@ -124,7 +131,7 @@ export function createCli(deps) {
         if (!intelUrl || !token) {
             return fail("INTEL_URL and a short-lived INTEL_OPERATOR_TOKEN must be set.");
         }
-        const response = await deps.fetch(`${intelUrl}/api/v1/search/reindex`, {
+        const response = await deps.fetch(`${intelUrl}/api/v1/nodes/reindex`, {
             method: "POST",
             headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
             body: "{}",

package/dist/flows/flows.d.ts

@@ -1,4 +1,4 @@
-import type { FlowGraph, FlowNode } from "@anchrd/intel-contract";
+import type { FlowGraph, FlowNode } from "@anchrd/intel-contract/flow";
 import type { CompiledFlow, FlowDeps, FlowService } from "./flows.types.js";
 type SubflowNode = Extract<FlowNode, {
     kind: "subflow";

package/dist/flows/flows.js

@@ -1,4 +1,4 @@
-import { flowNodeLayer } from "@anchrd/intel-contract";
+import { flowNodeLayer } from "@anchrd/intel-contract/flow";
 import { IntelError } from "../shared/intel-error/intel-error.js";
 import { plainTitle } from "../shared/plain-title/plain-title.js";
 function invalid(detail) {

package/dist/flows/flows.types.d.ts

@@ -1,4 +1,7 @@
-import type { ArchiveFlowInput, CancelFlowRunInput, CompleteFlowRunStepInput, CreateFlowInput, Flow, FlowDocument, FlowGraph, FlowPublishPreview, FlowRequirements, FlowRun, FlowRunHistory, FlowRunList, FlowRunStep, FlowValidation, FlowVersion, FlowVersionList, FlowVersionSummary, GetFlowVersionInput, ListFlowRunsInput, ListFlowsInput, Node, PreviewFlowPublishInput, PublishFlowInput, RelationGraph, RelationGraphInput, ResourceVerb, SaveFlowVersionInput, StartFlowRunInput, UnpublishFlowInput, UpdateFlowInput } from "@anchrd/intel-contract";
+import type { ArchiveFlowInput, CreateFlowInput, Flow, FlowDocument, FlowGraph, FlowPublishPreview, FlowRequirements, FlowValidation, FlowVersion, FlowVersionList, FlowVersionSummary, GetFlowVersionInput, ListFlowsInput, PreviewFlowPublishInput, PublishFlowInput, RelationGraph, RelationGraphInput, SaveFlowVersionInput, UnpublishFlowInput, UpdateFlowInput } from "@anchrd/intel-contract/flow";
+import type { CancelFlowRunInput, CompleteFlowRunStepInput, FlowRun, FlowRunHistory, FlowRunList, FlowRunStep, ListFlowRunsInput, StartFlowRunInput } from "@anchrd/intel-contract/flow-run";
+import type { Node } from "@anchrd/intel-contract/node";
+import type { ResourceVerb } from "@anchrd/intel-contract/share";
 export type FlowPrincipal = Pick<FlowActor, "id" | "email" | "isAdmin">;
 export type FlowCallReach = "subtree" | "library" | "out-of-reach";
 export interface FlowRunChainEntry {