@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.11

package/dist/catalog/claude/agents.js

@@ -13,16 +13,21 @@ import { item } from "./report.js";
 export const GENERATED_AGENTS_DIR = ".capybara-generated/agents";
 /** Claude Code tool names -> Capybara tool keys (spec §16.4; anything else is dropped). */
 const TOOL_MAP = {
-    Bash: "sandbox_bash",
-    Read: "sandbox_read",
-    Write: "sandbox_write",
-    Edit: "sandbox_edit",
-    MultiEdit: "sandbox_edit",
-    Glob: "sandbox_glob",
-    Grep: "sandbox_grep",
-    Skill: "skill_load",
-    TodoWrite: "todo__write",
-    ToolSearch: "tool_search",
+    Bash: "Bash",
+    Read: "Read",
+    Write: "Write",
+    Edit: "Edit",
+    MultiEdit: "Edit",
+    Glob: "Glob",
+    Grep: "Grep",
+    Skill: "Skill",
+    AskUserQuestion: "AskUserQuestion",
+    ToolSearch: "ToolSearch",
+    Agent: "Agent",
+    Task: "Agent",
+    TodoWrite: "plugin__todo__write",
+    WebFetch: "WebFetch",
+    WebSearch: "WebSearch",
 };
 /** Claude ignores these for plugin agents: `not_applicable`. */
 const NOT_APPLICABLE = new Set(["permissionMode", "hooks", "mcpServers"]);

package/dist/catalog/claude/translate.js

@@ -836,6 +836,9 @@ export function translateClaudePlugin(files, o) {
         // the raw Claude agents/*.md the tree still holds and parse them as Capybara templates
         // (batch 12 review I1); normalizedManifest drops an empty list, so digests are unchanged
         agents: agents.agents.map((a) => ({ path: `./${a.path}` })),
+        // always empty, for the same reason: a Claude Code plugin's themes/*.json are not Capybara
+        // themes (themes spec §4); normalizedManifest drops the empty list
+        themes: [],
     };
     const checked = parsePluginManifest(manifest);
     if ("errors" in checked) {

package/dist/catalog/cli.d.ts

@@ -4,11 +4,21 @@ import { type ExtensionCli } from "../extensions/cli.js";
 import type { KernelLogger } from "../log.js";
 import { CatalogService } from "./catalog.service.js";
 import { PluginImport } from "./plugin-import.js";
+import type { PluginScope } from "./scope.js";
 /** {@link openCatalogCli}'s result: the extension CLI context plus the catalog services. */
 export interface CatalogCli extends ExtensionCli {
     catalog: CatalogService;
     /** Plugin import (prepare / confirm). The CLI acts without an account (actor `null`). */
     imports: PluginImport;
+    /**
+     * After an import's confirm: enqueues the item's plugin scope sync, as the admin console's
+     * confirm does, when its scope turns it on by itself (`all` or `named`). A failure only warns
+     * (the next worker start enqueues every item); returns whether it was enqueued.
+     */
+    enqueueScopeSync(item: {
+        id: string;
+        scope: PluginScope;
+    }): Promise<boolean>;
 }
 /** What the CLI can do with the deployment's object store, and why not when it cannot. */
 export type CliObjectStore = {
@@ -32,9 +42,10 @@ export type CliObjectStore = {
  */
 export declare function loadCliObjectStore(cli: Pick<ExtensionCli, "inspected" | "deploymentConfigs" | "deploymentConfigOf" | "approvals" | "config" | "configIssues" | "installs" | "packageSet" | "readPackage">, log: Pick<KernelLogger, "warn">, syncDir: string): Promise<CliObjectStore>;
 /**
- * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} plus
- * {@link PluginImport} and {@link CatalogService}. Imports run with actor `null` (the operator of the
- * deployment, like `capybara extensions install`: no enterprise-admin re-check, audits without an
+ * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} with the
+ * catalog's {@link CatalogImportModule}, so {@link PluginImport} and {@link CatalogService} are the
+ * kernel's providers. Imports run with actor `null` (the operator of the
+ * deployment, like `capybara extensions install`: no super-admin re-check, audits without an
  * actor, permission snapshots written with source `cli`). Files of the plugin (skills, connector
  * templates, icons) go to the deployment's object store, set up in-process from the declared or
  * installed object-store extension (see {@link loadCliObjectStore}; an installed package is synced

package/dist/catalog/cli.js

@@ -8,10 +8,15 @@ import { openExtensionCli } from "../extensions/cli.js";
 import { assertSecretsReachable } from "../extensions/host.js";
 import { importExtensionModule, matchesSection } from "../extensions/instance.js";
 import { packageRootOf, syncPackage } from "../extensions/sync.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { addJobOnce } from "../infra/queue/add-job-once.js";
+import { REDIS } from "../infra/tokens.js";
 import { packagePath } from "../packages/tgz.js";
-import { StorageService } from "../storage/storage.service.js";
+import { PrefixedStorage } from "../storage/storage.service.js";
+import { CatalogImportModule } from "./catalog.module.js";
 import { CatalogService } from "./catalog.service.js";
 import { PluginImport } from "./plugin-import.js";
+import { PLUGIN_SCOPE_QUEUE, scopeItemJob } from "./scope-sync.js";
 /**
  * Sets up the deployment's object-store extension inside the CLI process. The CLI hosts no
  * extensions, so this runs only the provider's `setup` with a context that offers `config` and
@@ -131,7 +136,7 @@ export async function loadCliObjectStore(cli, log, syncDir) {
     return { store: undefined, reason: reasons.join("; ") };
 }
 /** `storage.unavailable` with the CLI's constraint spelled out (the generic text points to a plugin install). */
-class CliStorage extends StorageService {
+class CliStorage extends PrefixedStorage {
     reason;
     constructor(deps, reason) {
         super(deps);
@@ -144,9 +149,10 @@ class CliStorage extends StorageService {
     }
 }
 /**
- * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} plus
- * {@link PluginImport} and {@link CatalogService}. Imports run with actor `null` (the operator of the
- * deployment, like `capybara extensions install`: no enterprise-admin re-check, audits without an
+ * The CLI's plugin catalog context (`capybara plugins *`): {@link openExtensionCli} with the
+ * catalog's {@link CatalogImportModule}, so {@link PluginImport} and {@link CatalogService} are the
+ * kernel's providers. Imports run with actor `null` (the operator of the
+ * deployment, like `capybara extensions install`: no super-admin re-check, audits without an
  * actor, permission snapshots written with source `cli`). Files of the plugin (skills, connector
  * templates, icons) go to the deployment's object store, set up in-process from the declared or
  * installed object-store extension (see {@link loadCliObjectStore}; an installed package is synced
@@ -154,7 +160,7 @@ class CliStorage extends StorageService {
  * plugin does not bring are checked statically only (the CLI loads no connector).
  */
 export async function openCatalogCli(config, log, opts = {}) {
-    const cli = await openExtensionCli(config, log, opts);
+    const cli = await openExtensionCli(config, log, { ...opts, modules: [CatalogImportModule] });
     let syncDir;
     const removeSyncDir = async () => {
         if (syncDir !== undefined)
@@ -167,36 +173,37 @@ export async function openCatalogCli(config, log, opts = {}) {
             provider: () => store,
             plugins: async () => cli.inspected.map((p) => p.manifest.name),
         }, "reason" in rest ? rest.reason : undefined);
-        const declared = new Map(cli.inspected.map((p) => [p.manifest.name, p.source]));
-        const imports = new PluginImport({
-            db: cli.db,
-            config: () => config,
-            storage,
-            installs: cli.installs,
-            ops: cli.ops,
-            blobs: { get: (sha256) => cli.readPackage(sha256) },
-            declared: () => declared,
-            // The CLI loads no connectors: templates get static checks only (the org install re-checks)
-            findConnector: () => undefined,
-            connectorsLoaded: false,
-            log,
-        });
-        const catalog = new CatalogService({
-            db: cli.db,
-            config: () => config,
-            installs: cli.installs,
-            ops: cli.ops,
-            pluginImport: imports,
-            // Unreachable from the CLI: only marketplace imports (CatalogService.importFromMarketplace)
-            // download archives, and the CLI offers file, npm and direct git imports only.
-            fetchArchive: () => Promise.reject(new ApiError("internal", "marketplace imports are not available in the CLI")),
-            // Only marketplace imports send a marketplace token; a direct git import has none
-            marketplaceToken: async () => undefined,
-        });
+        // Plugin files go to that store; connector templates get static checks only (the CLI loads
+        // no connector; the org install re-checks them). Config-declared names come from the
+        // inspection (the registry), marketplace imports are not offered by the CLI.
+        const imports = cli.app.get(PluginImport);
+        imports.useCliStorage(storage);
+        const catalog = cli.app.get(CatalogService);
+        const db = cli.app.get(KernelDb);
+        const redis = cli.app.get(REDIS);
         return {
             ...cli,
             catalog,
             imports,
+            async enqueueScopeSync(item) {
+                if (item.scope === "optional")
+                    return false;
+                try {
+                    const row = await db.db
+                        .selectFrom("catalog_items")
+                        .select("scope_version")
+                        .where("id", "=", item.id)
+                        .executeTakeFirst();
+                    if (!row)
+                        return false;
+                    await addJobOnce(redis, PLUGIN_SCOPE_QUEUE, scopeItemJob(item.id, row.scope_version));
+                    return true;
+                }
+                catch (err) {
+                    log.warn("cannot enqueue the plugin scope sync; the next worker start converges the orgs", { itemId: item.id, err });
+                    return false;
+                }
+            },
             async close() {
                 await cli.close();
                 await removeSyncDir();

package/dist/catalog/component-promotion.d.ts

@@ -0,0 +1,96 @@
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { ApiError } from "../errors.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { StorageService } from "../storage/storage.service.js";
+/** The kinds an org owns as rows of its own (connector templates have none). */
+export type PromotableKind = "skill" | "agent_template";
+/**
+ * An org's own skill (org scope) or agent template, as the admin component routes see it: not
+ * linked (`link` null), or linked to a platform row the same org owns (`link`: that row, already
+ * promoted). A copy linked to a platform row of another owner is never an `OrgRow`.
+ */
+export interface OrgRow {
+    kind: PromotableKind;
+    id: string;
+    orgId: string;
+    name: string;
+    /** The roster plugin of an agent template (null: a bare `<name>`); null for skills. */
+    plugin: string | null;
+    version: number;
+    shareable: boolean;
+    /** The platform row the org promoted it to, or null while it is an org row only. */
+    link: string | null;
+    /**
+     * Content the org created itself (ruling P3-46): a skill without plugin provenance
+     * (`catalog_item_id` null); an agent template without a plugin and a catalog item (an org
+     * template saved from an agent, ruling P4-13). Anything else is refused with 409
+     * `catalog.not_owned`.
+     */
+    ownable: boolean;
+}
+/** A promotion whose files are copied ({@link ComponentPromotion.prepare}), waiting for its rows. */
+export interface PreparedPromotion {
+    readonly kind: PromotableKind;
+    readonly orgRowId: string;
+    readonly orgId: string;
+    /** The platform id it gets (the existing one when the row is promoted already). */
+    readonly platformId: string;
+    /** The org row's version the files were copied from. */
+    readonly version: number;
+    readonly already: boolean;
+    /** Where the files were copied (a fresh prefix, ruling P3-45); null: nothing copied. */
+    readonly prefix: string | null;
+}
+/** The org row changed between {@link ComponentPromotion.prepare} and its transaction: prepare again. */
+export declare class PromotionStale extends Error {
+}
+/** How many times a caller prepares again after {@link PromotionStale}. */
+export declare const PROMOTION_ATTEMPTS = 3;
+/** 409 `catalog.not_owned`: only the org's own rows can be shared (P3-6). */
+export declare function notOwnedError(what: string): ApiError;
+/** 409 `component.version_stale`: the org row kept changing while it was being promoted. */
+export declare const promotionStaleError: () => ApiError;
+/**
+ * Promotes an org's own skill or agent template to a platform row when it is first shared
+ * (ruling P3-3). Stateless, shared by every replica.
+ */
+export declare class ComponentPromotion {
+    private readonly kdb;
+    /** Where files are read and written (the kernel's object storage). */
+    private readonly files;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, 
+    /** Where files are read and written (the kernel's object storage). */
+    files: StorageService, txHost: TransactionHost);
+    private get db();
+    /**
+     * The live org row `id` of `kind` (an org-scope skill, an agent template) of a live org, when it
+     * is the org's own (see {@link OrgRow}); undefined otherwise.
+     */
+    orgRow(kind: PromotableKind, id: string, forUpdate?: boolean): Promise<OrgRow | undefined>;
+    /**
+     * The first phase, outside any transaction: reads the org row and (a skill) copies its current
+     * version's files to `deployment/platform/skills/<platformId>/<version>/`, checking each file
+     * against the manifest. A row promoted already needs nothing. A failed copy throws and nothing is
+     * linked (the copied files stay unreferenced). Missing or not the org's own -> 404.
+     */
+    prepare(kind: PromotableKind, orgRowId: string): Promise<PreparedPromotion>;
+    /** Deletes a prepared promotion's files after its transaction failed (best effort, P3-45). */
+    discard(p: PreparedPromotion): Promise<void>;
+    /**
+     * The second phase, in the caller's transaction: re-reads the org row under its lock (after the
+     * org row, so an org deletion is serialized), checks the share gate on it (409
+     * `catalog.not_shareable`) and writes the platform row (`current_version` = the org row's, one
+     * version row at that number), its list `[owner]`, and the link (no pin). Idempotent: a row the
+     * org promoted already returns its platform id. A version written since {@link prepare} ->
+     * {@link PromotionStale}; a live platform row of the same name created in this org already (a
+     * shared item whose owner deleted it and then made a new one) -> 409 `plugin.skill_conflict`.
+     * Audits `component.promoted`. Returns the platform id.
+     */
+    promote(p: PreparedPromotion, actor: string | null): Promise<string>;
+    /** Copies the skill's current version files to its platform prefix (outside any transaction). */
+    private copySkillFiles;
+}
+/** {@link ComponentPromotion.orgRow} through `db` (readers outside the provider). */
+export declare function readOrgRow(db: KernelSchemaDb, kind: PromotableKind, id: string, forUpdate?: boolean): Promise<OrgRow | undefined>;