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

package/dist/platform/exclusions.js

@@ -267,14 +267,14 @@ export const PLATFORM_EXCLUSIONS = [
         category: "transport",
         reason: "Serves sandbox file bytes",
     },
-    // environments (personal cloud environments, environments design phase 1)
+    // devices (personal cloud devices, environments design phase 1)
     // connected machines (environments design phase 2): device sign-in by the program and on the
     // confirmation page, and disconnecting a machine. The machine's WebSocket (`GET /device/connect`)
     // is a raw gateway-role route, not a Nest controller, so it is not listed (like the webhook)
     {
-        route: "DELETE /api/v1/orgs/:orgId/environments/:id/machine",
+        route: "DELETE /api/v1/orgs/:orgId/devices/:id/machine",
         category: "human-only",
-        reason: "Disconnects a person's own machine (revokes its credential); a trust decision taken on the environment's page",
+        reason: "Disconnects a person's own machine (revokes its credential); a trust decision taken on the device's page",
     },
     {
         route: "POST /api/v1/device/authorize",
@@ -608,6 +608,16 @@ export const PLATFORM_EXCLUSIONS = [
         category: "secret",
         reason: "Writes the caller's connector credentials",
     },
+    {
+        route: "GET /api/v1/orgs/:orgId/connectors/:connectorId/tool-policies/me",
+        category: "internal",
+        reason: "Display list of the connector card's 权限 sheet; connectors.get gives an agent the tools and their org defaults",
+    },
+    {
+        route: "PUT /api/v1/orgs/:orgId/connectors/:connectorId/tool-policies/me",
+        category: "human-only",
+        reason: "A member's own tool policies decide what agents may call with their connection without asking; an agent must never loosen them for itself",
+    },
     {
         route: "DELETE /api/v1/orgs/:orgId/connectors/:connectorId/credentials/me",
         category: "secret",
@@ -644,6 +654,11 @@ export const PLATFORM_EXCLUSIONS = [
         category: "internal",
         reason: "Navigation entries of the web shell (panels, pages, embeds); nothing an agent acts on",
     },
+    {
+        route: "GET /api/v1/orgs/:orgId/ui/arrangement",
+        category: "internal",
+        reason: "Listing for the 界面位置 page; the arrangement is read and written through org-settings / admin settings",
+    },
     {
         route: "GET /api/v1/orgs/:orgId/ui/views/:plugin/:id",
         category: "transport",
@@ -664,6 +679,36 @@ export const PLATFORM_EXCLUSIONS = [
         category: "transport",
         reason: "Server-sent event stream of UI invalidations",
     },
+    {
+        route: "GET /api/v1/admin/ui/contributions",
+        category: "internal",
+        reason: "Navigation entries of the admin console (platform pages)",
+    },
+    {
+        route: "GET /api/v1/admin/ui/arrangement",
+        category: "internal",
+        reason: "Listing for the 界面位置 page; the arrangement is read and written through org-settings / admin settings",
+    },
+    {
+        route: "GET /api/v1/admin/ui/views/:plugin/:id",
+        category: "transport",
+        reason: "Renders an extension UI view for the web app",
+    },
+    {
+        route: "POST /api/v1/admin/ui/actions/:plugin/:id",
+        category: "transport",
+        reason: "Runs an extension UI action from the web app",
+    },
+    {
+        route: "POST /api/v1/admin/ui/embeds/:plugin/:id/token",
+        category: "transport",
+        reason: "Issues an embed token for an iframe",
+    },
+    {
+        route: "GET /api/v1/admin/ui/stream",
+        category: "transport",
+        reason: "Server-sent event stream of UI invalidations",
+    },
     // themes (themes spec §8-§9)
     {
         route: "GET /api/v1/themes/:id/:version/theme.css",

package/dist/platform/operation.js

@@ -84,11 +84,15 @@ export const PLATFORM_DOMAINS = [
         description: "The org's settings (tool search, language, sandbox policy, the Platform tool switch, the default theme): read and change.",
     },
     {
-        id: "environments",
-        description: "Your own cloud environments (the workspaces your conversations run in): list, read, create, rename, delete, wipe the files.",
+        id: "devices",
+        description: "Your own cloud devices (the workspaces your conversations run in): list, read, create, rename, delete, wipe the files.",
     },
     {
         id: "themes",
         description: "The themes on in this org, the one in effect for you and the org's theme setting: list. Themes are set through your preferences, the org settings and the deployment settings.",
     },
+    {
+        id: "ui",
+        description: "The UI slots an extension can contribute to (the catalog): list. A slot id is a ui contribution's `slot` in a plugin manifest.",
+    },
 ];

package/dist/platform/ops/admin.ops.js

@@ -40,6 +40,7 @@ const SettingsInput = DEPLOYMENT_SETTINGS_PATCH.pick({
     customSkills: true,
     orgMarketplaceBrowse: true,
     uiTheme: true,
+    uiArrangement: true,
 }).strict();
 const ProviderId = ModelProviderParams.shape.provider.describe("The model provider (models.platform-list), e.g. the plugin name of its extension.");
 /** `provider/model` of a purpose target, or null. */
@@ -121,7 +122,7 @@ let AdminOperations = class AdminOperations {
             }),
             defineOperation({
                 id: "admin.update-settings",
-                description: "Change deployment settings (super admin); give only the keys to change: orgCreation (anyone or super_admin), priceCurrency (ISO 4217 code), customConnectors / customSkills (allow or deny: whether orgs may create their own instead of installing from the catalog), orgMarketplaceBrowse (true or false), uiTheme ({ id }: the platform default theme, a platform theme whose scope is all, or null for the built-in theme; it is what every org falls back to and what the sign-in pages show). Per-org limits are orgs.set-limits.",
+                description: "Change deployment settings (super admin); give only the keys to change: orgCreation (anyone or super_admin), priceCurrency (ISO 4217 code), customConnectors / customSkills (allow or deny: whether orgs may create their own instead of installing from the catalog), orgMarketplaceBrowse (true or false), uiTheme ({ id }: the platform default theme, a platform theme whose scope is all, or null for the built-in theme; it is what every org falls back to and what the sign-in pages show), uiArrangement ({ <slot>: { hidden, order } }: the platform default arrangement of UI slots, with contribution keys <extension>/<contribution>; hidden ones are not listed but still open by URL; null for a slot removes its entry). Per-org limits are orgs.set-limits.",
                 input: SettingsInput.refine((b) => Object.keys(b).length > 0, {
                     message: "at least one setting is required",
                 }),
@@ -148,7 +149,7 @@ let AdminOperations = class AdminOperations {
                         : { ok: false, code: "validation_failed", message: r.error.issues[0]?.message ?? "" };
                 },
                 summary: async (i) => {
-                    const { uiTheme, ...rest } = i;
+                    const { uiTheme, uiArrangement, ...rest } = i;
                     const parts = Object.entries(rest).map(([k, v]) => `${k}=${String(v)}`);
                     const zh = [...parts];
                     const en = [...parts];
@@ -158,6 +159,11 @@ let AdminOperations = class AdminOperations {
                         zh.push(`uiTheme=${uiTheme.id === null ? "内置主题" : (name?.zh ?? uiTheme.id)}`);
                         en.push(`uiTheme=${uiTheme.id === null ? "built-in theme" : (name?.en ?? uiTheme.id)}`);
                     }
+                    if (uiArrangement !== undefined) {
+                        const slots = Object.keys(uiArrangement).join(", ");
+                        zh.push(`uiArrangement（${slots}）`);
+                        en.push(`uiArrangement (${slots})`);
+                    }
                     return {
                         zh: `修改平台部署设置：${zh.join("，")}`,
                         en: `Change the deployment settings: ${en.join(", ")}`,

package/dist/platform/ops/agents.ops.js

@@ -40,6 +40,15 @@ const RouteSkills = Def.skills.unwrap();
 const Skills = RouteSkills.pick({ pinned: true })
     .extend({ orgSkills: RouteSkills.shape.orgSkills.unwrap() })
     .strict();
+/**
+ * Whether `next` sets an `allow` that `current` does not have (decision 2026-11-09: `allow` on a
+ * connector tool lets an agent call it without asking). Such a change is confirmed every time and
+ * never remembered, so an agent can never loosen its own policies on a grant the person remembered
+ * for ordinary edits.
+ */
+function addsAllow(next, current) {
+    return Object.entries(next ?? {}).some(([k, v]) => v === "allow" && current?.[k] !== "allow");
+}
 /** The definition fields an agent can set through the tool; the rest keep the web's defaults. */
 const Fields = {
     name: Def.name,
@@ -156,8 +165,10 @@ let AgentsOperations = class AgentsOperations {
      * `agents.update`'s class (spec §13): `personal` (may be remembered) only on a private agent the
      * actor owns; any other agent the actor may edit is shared, so each change is confirmed.
      */
-    async updateClass(agentId, ctx) {
+    async updateClass(agentId, toolPolicies, ctx) {
         const a = await this.agents.get(ctx.orgId, agentId, ctx.actorAccountId);
+        if (addsAllow(toolPolicies, a.definition.toolPolicies))
+            return "org";
         return a.visibility === "private" && a.ownerAccountId === ctx.actorAccountId
             ? "personal"
             : "org";
@@ -221,6 +232,8 @@ let AgentsOperations = class AgentsOperations {
                 omits: ["memberIds", "profile"],
                 loosens: { visibility: "optional: the operation creates private agents only" },
                 confirm: "personal",
+                // an `allow` loosens: never on a remembered grant
+                confirmFor: async (i) => addsAllow(i.definition.toolPolicies, undefined) ? "org" : "personal",
                 summary: (i) => ({
                     zh: `新建私有智能体「${i.definition.name}」`,
                     en: `Create private agent "${i.definition.name}"`,
@@ -246,7 +259,7 @@ let AgentsOperations = class AgentsOperations {
             }),
             defineOperation({
                 id: "agents.update",
-                description: 'Change an agent you may edit: your own, private or shared, and as an org admin any agent of the org. Send the version you read from agents.get and only the fields to change; the others keep their value. The description (one short paragraph, "" removes it) is saved with the definition; the avatar and quick actions are changed with agents.update-profile. disabledTools replaces the whole list of turned-off tools (send [] to turn every tool on). A version that is no longer current is refused, so read the agent again first. The visibility cannot be changed here (that is done on the agents page of the web app). A change to your own private agent may be remembered by the person; a change to a shared agent is confirmed every time.',
+                description: 'Change an agent you may edit: your own, private or shared, and as an org admin any agent of the org. Send the version you read from agents.get and only the fields to change; the others keep their value. The description (one short paragraph, "" removes it) is saved with the definition; the avatar and quick actions are changed with agents.update-profile. disabledTools replaces the whole list of turned-off tools (send [] to turn every tool on). A version that is no longer current is refused, so read the agent again first. The visibility cannot be changed here (that is done on the agents page of the web app). A change to your own private agent may be remembered by the person; a change to a shared agent, or one that sets a tool policy to allow, is confirmed every time.',
                 input: z
                     .object({
                     agentId: AgentId,
@@ -289,7 +302,7 @@ let AgentsOperations = class AgentsOperations {
                         next: "The agent changed since you read it: read it again with agents.get, then send its current version.",
                     },
                 ],
-                confirmFor: (i, ctx) => this.updateClass(i.agentId, ctx),
+                confirmFor: (i, ctx) => this.updateClass(i.agentId, i.toolPolicies, ctx),
                 summary: async (i, ctx) => {
                     const a = await this.agents.get(ctx.orgId, i.agentId, ctx.actorAccountId);
                     const name = named(a.definition.name);
@@ -353,7 +366,7 @@ let AgentsOperations = class AgentsOperations {
                 // needs no declaration: an input that accepts less than the route passes the parity test.
                 omits: ["expectedUpdatedAt"],
                 confirm: "personal",
-                confirmFor: (i, ctx) => this.updateClass(i.agentId, ctx),
+                confirmFor: (i, ctx) => this.updateClass(i.agentId, undefined, ctx),
                 errors: [
                     {
                         code: "agent.not_found",
@@ -493,7 +506,7 @@ let AgentsOperations = class AgentsOperations {
                 confirm: "personal",
                 // destructive: asked every time and never remembered, a shared agent as an org write
                 rememberable: false,
-                confirmFor: (i, ctx) => this.updateClass(i.agentId, ctx),
+                confirmFor: (i, ctx) => this.updateClass(i.agentId, undefined, ctx),
                 errors: [
                     {
                         code: "agent.not_found",
@@ -578,7 +591,7 @@ let AgentsOperations = class AgentsOperations {
                 authz: { orgAction: "agents.create" },
                 mirrors: ["POST /api/v1/orgs/:orgId/agents/:agentId/pending-connectors/:key/bind"],
                 confirm: "personal",
-                confirmFor: (i, ctx) => this.updateClass(i.agentId, ctx),
+                confirmFor: (i, ctx) => this.updateClass(i.agentId, undefined, ctx),
                 errors: [
                     {
                         code: "agent.pending_connector_not_found",

package/dist/platform/ops/conversations.ops.d.ts

@@ -1,6 +1,6 @@
 import { type OnModuleInit } from "@nestjs/common";
 import { ConversationsService } from "../../conversations/conversations.service.js";
-import { ConversationEnvironmentStatus } from "../../conversations/environment-status.js";
+import { ConversationDeviceStatus } from "../../conversations/device-status.js";
 import { ConversationFiles } from "../../conversations/files.js";
 import { KernelDb } from "../../infra/database/kernel-db.js";
 import { PlatformOperations } from "../registry.js";
@@ -14,9 +14,9 @@ export declare class ConversationsOperations implements OnModuleInit {
     private readonly registry;
     private readonly conversations;
     private readonly files;
-    private readonly environment;
+    private readonly device;
     private readonly kdb;
-    constructor(registry: PlatformOperations, conversations: ConversationsService, files: ConversationFiles, environment: ConversationEnvironmentStatus, kdb: KernelDb);
+    constructor(registry: PlatformOperations, conversations: ConversationsService, files: ConversationFiles, device: ConversationDeviceStatus, kdb: KernelDb);
     /**
      * Whether `id` is the conversation this run belongs to: its ROOT (the Platform tool also runs in
      * sub-agents, whose own id is not the person's conversation). Stopping or deleting it would end

package/dist/platform/ops/conversations.ops.js

@@ -11,7 +11,7 @@ import { Inject, Injectable } from "@nestjs/common";
 import { z } from "zod";
 import { EventsQuery, FilesQuery, IdParams, ListQuery, PatchBody, SubagentsQuery, } from "../../conversations/conversations.schemas.js";
 import { ConversationsService, } from "../../conversations/conversations.service.js";
-import { ConversationEnvironmentStatus } from "../../conversations/environment-status.js";
+import { ConversationDeviceStatus } from "../../conversations/device-status.js";
 import { ConversationFiles } from "../../conversations/files.js";
 import { KernelDb } from "../../infra/database/kernel-db.js";
 import { rootConversationOf } from "../../runtime/subagents/child.js";
@@ -41,13 +41,13 @@ let ConversationsOperations = class ConversationsOperations {
     registry;
     conversations;
     files;
-    environment;
+    device;
     kdb;
-    constructor(registry, conversations, files, environment, kdb) {
+    constructor(registry, conversations, files, device, kdb) {
         this.registry = registry;
         this.conversations = conversations;
         this.files = files;
-        this.environment = environment;
+        this.device = device;
         this.kdb = kdb;
     }
     /**
@@ -348,12 +348,12 @@ let ConversationsOperations = class ConversationsOperations {
                 },
             }),
             defineOperation({
-                id: "conversations.environment",
-                description: "Read the environment one of your conversations works in and whether its instance is running or suspended; environment is null while the conversation has none. Takes the id from conversations.list.",
+                id: "conversations.device",
+                description: "Read the device one of your conversations works in and whether its instance is running or suspended; device is null while the conversation has none. Takes the id from conversations.list.",
                 input: Id,
                 example: { conversationId: "3f2b8a40-6c1d-4e0b-9a77-5d1e2c8b9f10" },
                 authz: { orgAction: "agents.use" },
-                mirrors: ["GET /api/v1/orgs/:orgId/conversations/:id/environment"],
+                mirrors: ["GET /api/v1/orgs/:orgId/conversations/:id/device"],
                 renames: { conversationId: "id" },
                 errors: [
                     {
@@ -363,7 +363,7 @@ let ConversationsOperations = class ConversationsOperations {
                 ],
                 confirm: "read",
                 run: async (input, ctx) => ({
-                    environment: await this.environment.get(ctx.orgId, input.conversationId, ctx.actorAccountId),
+                    device: await this.device.get(ctx.orgId, input.conversationId, ctx.actorAccountId),
                 }),
             }),
             defineOperation({
@@ -464,7 +464,7 @@ ConversationsOperations = __decorate([
     __param(0, Inject(PlatformOperations)),
     __param(1, Inject(ConversationsService)),
     __param(2, Inject(ConversationFiles)),
-    __param(3, Inject(ConversationEnvironmentStatus)),
+    __param(3, Inject(ConversationDeviceStatus)),
     __param(4, Inject(KernelDb))
 ], ConversationsOperations);
 export { ConversationsOperations };

package/dist/platform/ops/devices.ops.d.ts

@@ -0,0 +1,26 @@
+import { type OnModuleInit } from "@nestjs/common";
+import { DevicesService } from "../../devices/devices.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { PlatformOperations } from "../registry.js";
+/**
+ * Device operations of the `Platform` tool (environments design, phase 1): a person's own
+ * cloud devices. Phase 1 has personal devices only, visible to their owner alone, so
+ * these are `personal` writes. A cloud device carries no credentials or device connection;
+ * deleting one and wiping its files are `personal` writes that are never remembered.
+ */
+export declare class DevicesOperations implements OnModuleInit {
+    private readonly registry;
+    private readonly devices;
+    private readonly kdb;
+    constructor(registry: PlatformOperations, devices: DevicesService, kdb: KernelDb);
+    /**
+     * Whether `id` is the device the run works in: the one its root conversation is bound to
+     * (sub-agents use the root's). Deleting or wiping it would pull the sandbox from under the run.
+     */
+    private isRunsDevice;
+    /** The precheck of a destructive write: never the run's own device, then the service's. */
+    private precheckDestructive;
+    /** The device's name for a card; its id when it cannot be read. */
+    private label;
+    onModuleInit(): void;
+}

package/dist/platform/ops/devices.ops.js

@@ -0,0 +1,311 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { z } from "zod";
+import { DevicesService } from "../../devices/devices.service.js";
+import { DeviceNameBody, DeviceParams } from "../../devices/dto.js";
+import { deviceLabel } from "../../devices/label.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { rootConversationOf } from "../../runtime/subagents/child.js";
+import { defineOperation } from "../operation.js";
+import { PlatformOperations } from "../registry.js";
+import { precheckBy, viaAgent } from "./errors.js";
+import { named, orElse } from "./summary.js";
+const DeviceId = z.object({ deviceId: DeviceParams.shape.id }).strict();
+const Name = z.object({ name: DeviceNameBody.shape.name }).strict();
+/**
+ * Model-facing names are English: the default is "Personal", a default demoted by a provider
+ * switch "Personal (Docker sandbox)" (the web shows 「个人设备」 / 「个人设备（Docker 沙箱）」).
+ */
+const labelOf = (e) => deviceLabel(e, "en");
+/** A row's state: why it cannot be used now, else whether its instance runs. */
+function stateOf(e) {
+    if (!e.available) {
+        return {
+            state: "unavailable",
+            reason: "Its sandbox provider is no longer the deployment's current one.",
+            next: "Ask an org admin; use another device meanwhile.",
+        };
+    }
+    if (e.filesLost && e.source === "local") {
+        return {
+            state: "files_lost",
+            reason: "Its directory is gone from the connected machine.",
+            next: "Ask the person to run capybara-device logout, then capybara-device login into this device, on that machine.",
+        };
+    }
+    if (e.filesLost) {
+        return {
+            state: "files_lost",
+            reason: "Its file system is gone at the provider.",
+            next: "Wipe its files with devices.reset-files to use it again.",
+        };
+    }
+    return { state: e.instance?.status ?? "ready" };
+}
+const row = (e) => ({
+    id: e.id,
+    name: labelOf(e),
+    ...stateOf(e),
+    isDefault: e.isDefault,
+    source: e.source,
+    provider: e.provider,
+    online: e.online,
+    machine: e.machine && {
+        name: e.machine.name,
+        os: e.machine.os,
+        lastSeenAt: e.machine.lastSeenAt,
+    },
+    lastUsedAt: e.instance?.lastUsedAt ?? null,
+});
+/**
+ * Device operations of the `Platform` tool (environments design, phase 1): a person's own
+ * cloud devices. Phase 1 has personal devices only, visible to their owner alone, so
+ * these are `personal` writes. A cloud device carries no credentials or device connection;
+ * deleting one and wiping its files are `personal` writes that are never remembered.
+ */
+let DevicesOperations = class DevicesOperations {
+    registry;
+    devices;
+    kdb;
+    constructor(registry, devices, kdb) {
+        this.registry = registry;
+        this.devices = devices;
+        this.kdb = kdb;
+    }
+    /**
+     * Whether `id` is the device the run works in: the one its root conversation is bound to
+     * (sub-agents use the root's). Deleting or wiping it would pull the sandbox from under the run.
+     */
+    async isRunsDevice(id, ctx) {
+        const root = await rootConversationOf(this.kdb.db, ctx.conversationId);
+        const row = await this.kdb.db
+            .selectFrom("conversations")
+            .select("device_id")
+            .where("id", "=", root)
+            .where("org_id", "=", ctx.orgId)
+            .executeTakeFirst();
+        return row?.device_id === id;
+    }
+    /** The precheck of a destructive write: never the run's own device, then the service's. */
+    async precheckDestructive(id, ctx, verb, read) {
+        if (await this.isRunsDevice(id, ctx)) {
+            return {
+                ok: false,
+                code: "device.current",
+                message: `The device you are running in cannot be ${verb} from here.`,
+            };
+        }
+        return precheckBy(read);
+    }
+    /** The device's name for a card; its id when it cannot be read. */
+    label(ctx, id) {
+        return orElse(async () => named(labelOf(await this.devices.get(ctx.orgId, ctx.actorAccountId, id))), id);
+    }
+    onModuleInit() {
+        this.registry.register([
+            defineOperation({
+                id: "devices.list",
+                description: "List your own devices in this org: one compact row each (name, state, whether it is the default, source: cloud or local, provider, whether a local one is online and its machine, last use), plus the default and last used ids and whether new cloud devices can be made. The default device is shown as Personal; a former default left behind by a sandbox provider switch is shown as Personal (<provider>) and becomes the default again when that provider is back.",
+                input: z.object({}).strict(),
+                example: {},
+                authz: { orgAction: "agents.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/devices"],
+                confirm: "read",
+                run: async (_input, ctx) => {
+                    const l = await this.devices.list(ctx.orgId, ctx.actorAccountId);
+                    return {
+                        items: l.items.map(row),
+                        defaultId: l.defaultId,
+                        lastUsedId: l.lastUsedId,
+                        cloudAvailable: l.cloudAvailable,
+                    };
+                },
+            }),
+            defineOperation({
+                id: "devices.get",
+                description: "Read one of your devices with its source (cloud or local), provider, state, instance, the machine of a local one and whether it is online, limits and creation time. Takes the id from devices.list.",
+                input: DeviceId,
+                example: { deviceId: "4e8a0c1d-6b2f-4a37-8d19-3c5e7f9a1b20" },
+                authz: { orgAction: "agents.use" },
+                mirrors: ["GET /api/v1/orgs/:orgId/devices/:id"],
+                renames: { deviceId: "id" },
+                confirm: "read",
+                errors: [
+                    {
+                        code: "device.not_found",
+                        next: "Check the id with devices.list: you only see your own devices.",
+                    },
+                ],
+                run: async (input, ctx) => {
+                    const e = await this.devices.get(ctx.orgId, ctx.actorAccountId, input.deviceId);
+                    return { device: { ...e, name: labelOf(e), ...stateOf(e) } };
+                },
+            }),
+            defineOperation({
+                id: "devices.create",
+                description: "Create a personal cloud device with a name (1-64 characters, unique among yours, case-insensitive). It is ready at once; its instance and files are made on first use. It needs a sandbox provider and is limited per person.",
+                input: Name,
+                example: { name: "Data analysis" },
+                authz: { orgAction: "agents.use" },
+                mirrors: ["POST /api/v1/orgs/:orgId/devices"],
+                confirm: "personal",
+                errors: [
+                    {
+                        code: "device.name_taken",
+                        next: "You have a device with this name: pick another name, or read yours with devices.list.",
+                    },
+                    {
+                        code: "device.limit_reached",
+                        next: "You are at the limit: delete a device you no longer need with devices.delete, or use an existing one.",
+                    },
+                    {
+                        code: "device.current",
+                        next: "This conversation works in it: ask the person to wipe it on the web, or wipe a different one.",
+                    },
+                    {
+                        code: "device.unavailable",
+                        next: {
+                            superAdmin: "No sandbox provider is current: set one up in the admin console under extensions, then call again.",
+                            orgAdmin: "No sandbox provider is set up; ask the super admin.",
+                            member: "No sandbox provider is set up in this deployment; ask an org admin.",
+                        },
+                    },
+                ],
+                precheck: (i, ctx) => precheckBy(() => this.devices.checkCreate(ctx.orgId, ctx.actorAccountId, i.name)),
+                summary: (i) => ({
+                    zh: `新建个人云端设备「${named(i.name)}」`,
+                    en: `Create personal cloud device "${named(i.name)}"`,
+                }),
+                run: async (input, ctx) => {
+                    const e = await this.devices.create(ctx.orgId, ctx.actorAccountId, { name: input.name }, undefined, viaAgent("devices.create", ctx));
+                    return { device: row(e) };
+                },
+            }),
+            defineOperation({
+                id: "devices.delete",
+                description: "Delete one of your devices, the default one included: its instance and ALL its files are destroyed after the response and cannot be recovered. Conversations bound to it keep pointing at it and their sandbox tools then fail. The person confirms every delete; it is never remembered. The device this conversation works in cannot be deleted. Takes the id from devices.list.",
+                input: DeviceId,
+                example: { deviceId: "4e8a0c1d-6b2f-4a37-8d19-3c5e7f9a1b20" },
+                authz: { orgAction: "agents.use" },
+                mirrors: ["DELETE /api/v1/orgs/:orgId/devices/:id"],
+                renames: { deviceId: "id" },
+                confirm: "personal",
+                // destructive: asked every time and never remembered
+                rememberable: false,
+                errors: [
+                    {
+                        code: "device.not_found",
+                        next: "Check the id with devices.list: you only see your own devices.",
+                    },
+                    {
+                        code: "device.current",
+                        next: "This conversation works in it: ask the person to delete it on the web, or delete a different one.",
+                    },
+                ],
+                precheck: (i, ctx) => this.precheckDestructive(i.deviceId, ctx, "deleted", () => this.devices.get(ctx.orgId, ctx.actorAccountId, i.deviceId)),
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.deviceId);
+                    const c = await orElse(() => this.devices.boundConversations(ctx.orgId, ctx.actorAccountId, i.deviceId), 0);
+                    return {
+                        zh: `删除设备「${n}」：其中所有文件将被销毁且无法恢复；使用它的 ${c} 个对话将失去沙箱（沙箱工具会失败）`,
+                        en: `Delete device "${n}": all its files are destroyed and cannot be recovered; the ${c} conversations using it lose their sandbox (their sandbox tools fail)`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    await this.devices.remove(ctx.orgId, ctx.actorAccountId, input.deviceId, undefined, viaAgent("devices.delete", ctx));
+                    return { id: input.deviceId, deleted: true };
+                },
+            }),
+            defineOperation({
+                id: "devices.reset-files",
+                description: "Wipe one of your devices' files so it starts empty: ALL its files are destroyed (after running commands finish) and cannot be recovered; the next use creates a fresh workspace. Use it when a device reports its files are lost (not for a connected machine's device: its files are on the machine). The person confirms every reset; it is never remembered. The device this conversation works in cannot be wiped. Takes the id from devices.list.",
+                input: DeviceId,
+                example: { deviceId: "4e8a0c1d-6b2f-4a37-8d19-3c5e7f9a1b20" },
+                authz: { orgAction: "agents.use" },
+                mirrors: ["POST /api/v1/orgs/:orgId/devices/:id/files/reset"],
+                renames: { deviceId: "id" },
+                confirm: "personal",
+                rememberable: false,
+                errors: [
+                    {
+                        code: "device.not_found",
+                        next: "Check the id with devices.list: you only see your own devices.",
+                    },
+                    {
+                        code: "device.current",
+                        next: "This conversation works in it: ask the person to wipe it on the web, or wipe a different one.",
+                    },
+                    {
+                        code: "device.files_on_device",
+                        next: "Its files are on its connected machine: ask the person to run capybara-device logout, then capybara-device login into this device, on that machine.",
+                    },
+                    {
+                        code: "device.unavailable",
+                        next: {
+                            orgAdmin: "Its sandbox provider is no longer the current one: use another device, or ask the super admin about the provider.",
+                            member: "Its sandbox provider is no longer the current one: use another device, or ask an org admin.",
+                        },
+                    },
+                ],
+                precheck: (i, ctx) => this.precheckDestructive(i.deviceId, ctx, "wiped", () => this.devices.checkReset(ctx.orgId, ctx.actorAccountId, i.deviceId)),
+                summary: async (i, ctx) => {
+                    const n = await this.label(ctx, i.deviceId);
+                    return {
+                        zh: `清空设备「${n}」的文件：所有文件将被销毁且无法恢复`,
+                        en: `Wipe the files of device "${n}": all files are destroyed and cannot be recovered`,
+                    };
+                },
+                run: async (input, ctx) => {
+                    await this.devices.resetFiles(ctx.orgId, ctx.actorAccountId, input.deviceId, undefined, viaAgent("devices.reset-files", ctx));
+                    return { id: input.deviceId, reset: true };
+                },
+            }),
+            defineOperation({
+                id: "devices.rename",
+                description: "Rename one of your devices, the default one included (it then has a name). The new name is 1-64 characters and unique among yours, case-insensitive. Takes the id from devices.list.",
+                input: DeviceId.extend({ name: DeviceNameBody.shape.name }).strict(),
+                example: { deviceId: "4e8a0c1d-6b2f-4a37-8d19-3c5e7f9a1b20", name: "Reports" },
+                authz: { orgAction: "agents.use" },
+                mirrors: ["PATCH /api/v1/orgs/:orgId/devices/:id"],
+                renames: { deviceId: "id" },
+                confirm: "personal",
+                errors: [
+                    {
+                        code: "device.not_found",
+                        next: "Check the id with devices.list: you only see your own devices.",
+                    },
+                    {
+                        code: "device.name_taken",
+                        next: "You have a device with this name: pick another name.",
+                    },
+                ],
+                precheck: (i, ctx) => precheckBy(() => this.devices.checkRename(ctx.orgId, ctx.actorAccountId, i.deviceId, i.name)),
+                summary: async (i, ctx) => {
+                    const from = await orElse(async () => named(labelOf(await this.devices.get(ctx.orgId, ctx.actorAccountId, i.deviceId))), i.deviceId);
+                    return {
+                        zh: `将设备「${from}」重命名为「${named(i.name)}」`,
+                        en: `Rename device "${from}" to "${named(i.name)}"`,
+                    };
+                },
+                run: async (input, ctx) => ({
+                    device: row(await this.devices.rename(ctx.orgId, ctx.actorAccountId, input.deviceId, input.name, undefined, viaAgent("devices.rename", ctx))),
+                }),
+            }),
+        ]);
+    }
+};
+DevicesOperations = __decorate([
+    Injectable(),
+    __param(0, Inject(PlatformOperations)),
+    __param(1, Inject(DevicesService)),
+    __param(2, Inject(KernelDb))
+], DevicesOperations);
+export { DevicesOperations };