@aiworker/sdk 1.24.0

package/dist/workspace-schemas.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { GUEST_STORAGE_KEY_MAX, GUEST_STORAGE_VALUE_BYTES, GUEST_STORAGE_KEYS_MAX } from "./workspace.js";
+const identity = z.string().trim().min(1).max(1024);
+const state = z.enum(['loading', 'ready', 'error']);
+const worktree = z.object({
+    directory: identity, name: z.string(), branch: z.string(),
+    status: z.enum(['ready', 'pending', 'invalid', 'missing']),
+});
+export const guestWorkspaceQuerySchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('projects') }).strict(),
+    z.object({ kind: z.literal('worktrees'), projectId: identity }).strict(),
+    z.object({ kind: z.literal('sessions'), projectId: identity }).strict(),
+]);
+export const guestWorkspaceSnapshotSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('projects'), state, projects: z.array(z.object({ id: identity, name: z.string(), directory: identity })) }),
+    z.object({ kind: z.literal('worktrees'), projectId: identity, state, worktrees: z.array(worktree) }),
+    z.object({ kind: z.literal('sessions'), projectId: identity, state,
+        coverage: z.array(z.object({ directory: identity, state })),
+        sessions: z.array(z.object({
+            id: identity, title: z.string(), projectId: identity, directory: identity, parentId: identity.nullable(),
+            createdAt: z.number(), updatedAt: z.number(), archivedAt: z.number().nullable(), worktree: worktree.nullable(),
+            activity: z.enum(['unknown', 'idle', 'running', 'retrying', 'waiting-permission', 'waiting-question']),
+            outcome: z.enum(['completed', 'failed']).nullable(), items: z.array(z.object({ id: identity, data: z.json().optional() })),
+        })),
+    }),
+]);
+export const guestSessionWorktreeSchema = z.union([
+    z.boolean(),
+    z.object({ kind: z.literal('existing'), directory: identity }).strict(),
+    z.object({ kind: z.literal('new'), name: z.string().trim().min(1).max(200).optional(), baseBranch: z.string().trim().min(1).max(200).optional() }).strict(),
+]);
+const storageKey = z.string().min(1).max(GUEST_STORAGE_KEY_MAX);
+export const guestStorageRequestSchema = z.discriminatedUnion('op', [
+    z.object({ op: z.literal('get'), key: storageKey }).strict(),
+    z.object({ op: z.literal('delete'), key: storageKey }).strict(),
+    z.object({ op: z.literal('set'), key: storageKey, value: z.json().refine((value) => new TextEncoder().encode(JSON.stringify(value)).length <= GUEST_STORAGE_VALUE_BYTES) }).strict(),
+    z.object({ op: z.literal('keys') }).strict(),
+]);
+export const guestStorageResultSchema = z.union([
+    z.object({ storage: z.literal(true), op: z.literal('get'), found: z.literal(false) }),
+    z.object({ storage: z.literal(true), op: z.literal('get'), found: z.literal(true), value: z.json() }),
+    z.object({ storage: z.literal(true), op: z.enum(['set', 'delete']) }),
+    z.object({ storage: z.literal(true), op: z.literal('keys'), keys: z.array(storageKey).max(GUEST_STORAGE_KEYS_MAX) }),
+]);

package/dist/workspace.d.ts

@@ -0,0 +1,109 @@
+import type { JsonValue } from './contract.ts';
+export type GuestLoadState = 'loading' | 'ready' | 'error';
+export type GuestProject = {
+    id: string;
+    name: string;
+    directory: string;
+};
+export type GuestWorktree = {
+    directory: string;
+    name: string;
+    branch: string;
+    status: 'ready' | 'pending' | 'invalid' | 'missing';
+};
+export type GuestSessionActivity = 'unknown' | 'idle' | 'running' | 'retrying' | 'waiting-permission' | 'waiting-question';
+export type GuestSessionRecord = {
+    id: string;
+    title: string;
+    projectId: string;
+    directory: string;
+    parentId: string | null;
+    createdAt: number;
+    updatedAt: number;
+    archivedAt: number | null;
+    worktree: GuestWorktree | null;
+    activity: GuestSessionActivity;
+    /** Observed turn outcome, never a task status. Unknown history stays null. */
+    outcome: 'completed' | 'failed' | null;
+    items: {
+        id: string;
+        data?: JsonValue;
+    }[];
+};
+export type GuestDirectoryCoverage = {
+    directory: string;
+    state: GuestLoadState;
+};
+export type GuestProjectsSnapshot = {
+    kind: 'projects';
+    state: GuestLoadState;
+    projects: GuestProject[];
+};
+export type GuestWorktreesSnapshot = {
+    kind: 'worktrees';
+    projectId: string;
+    state: GuestLoadState;
+    worktrees: GuestWorktree[];
+};
+export type GuestSessionsSnapshot = {
+    kind: 'sessions';
+    projectId: string;
+    state: GuestLoadState;
+    coverage: GuestDirectoryCoverage[];
+    sessions: GuestSessionRecord[];
+};
+export type GuestWorkspaceSnapshot = GuestProjectsSnapshot | GuestWorktreesSnapshot | GuestSessionsSnapshot;
+export type GuestWorkspaceQuery = {
+    kind: 'projects';
+} | {
+    kind: 'worktrees';
+    projectId: string;
+} | {
+    kind: 'sessions';
+    projectId: string;
+};
+export type GuestWorkspaceSubscription = {
+    subscriptionId: string;
+    query: GuestWorkspaceQuery;
+};
+export type GuestWorkspaceUpdate = {
+    subscriptionId: string;
+    snapshot: GuestWorkspaceSnapshot;
+};
+export declare const GUEST_STORAGE_KEY_MAX = 128;
+export declare const GUEST_STORAGE_VALUE_BYTES = 65536;
+export declare const GUEST_STORAGE_TOTAL_BYTES = 2097152;
+export declare const GUEST_STORAGE_KEYS_MAX = 2000;
+export type GuestStorageRequest = {
+    op: 'get' | 'delete';
+    key: string;
+} | {
+    op: 'set';
+    key: string;
+    value: JsonValue;
+} | {
+    op: 'keys';
+};
+export type GuestStorageResult = {
+    storage: true;
+} & ({
+    op: 'get';
+    found: false;
+} | {
+    op: 'get';
+    found: true;
+    value: JsonValue;
+} | {
+    op: 'set' | 'delete';
+} | {
+    op: 'keys';
+    keys: string[];
+});
+export type GuestSessionWorktree = boolean | {
+    kind: 'existing';
+    directory: string;
+} | {
+    kind: 'new';
+    name?: string;
+    baseBranch?: string;
+};

package/dist/workspace.js

@@ -0,0 +1,4 @@
+export const GUEST_STORAGE_KEY_MAX = 128;
+export const GUEST_STORAGE_VALUE_BYTES = 65_536;
+export const GUEST_STORAGE_TOTAL_BYTES = 2_097_152;
+export const GUEST_STORAGE_KEYS_MAX = 2_000;

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@aiworker/sdk",
+  "version": "1.24.0",
+  "description": "Contract for AiWorker guests: manifest parse and iframe host bridge.",
+  "private": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://roweb.cn/roweb/aihander.git",
+    "directory": "packages/sdk"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./ui": {
+      "types": "./dist/ui/index.d.ts",
+      "default": "./dist/ui/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/schemas.d.ts",
+      "default": "./dist/schemas.js"
+    }
+  },
+  "bin": {
+    "openchamber-guest-bundle": "./scripts/bundle-guest.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint \"./{src,examples}/**/*.ts\" --config ../../eslint.config.js",
+    "bundle": "bun scripts/bundle-guest.ts",
+    "test": "node ../../scripts/run-isolated-tests.mjs src scripts",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\""
+  },
+  "files": [
+    "dist",
+    "scripts/bundle-guest.ts",
+    "README.md",
+    "API.md",
+    "DOCUMENTATION.md",
+    "GUEST_SERVICES.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6"
+  }
+}

package/scripts/bundle-guest.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const usage = 'Usage: openchamber-guest-bundle [--node] <entry.ts> <outfile.js>';
+
+const args = process.argv.slice(2);
+const nodeTarget = args.includes('--node');
+const [entry, outfile] = args.filter((arg) => arg !== '--node');
+if (!entry || !outfile) {
+  console.error(usage);
+  process.exit(1);
+}
+
+const bun = globalThis.Bun;
+if (!bun?.build) {
+  console.error('This bundle command needs Bun.');
+  process.exit(1);
+}
+
+// A panel runs in a sandboxed iframe that cannot load ESM, so it gets a
+// browser IIFE. A local service runs under Node, so `--node` keeps ESM and
+// leaves the Node built-ins external.
+const result = await bun.build({
+  entrypoints: [resolve(entry)],
+  format: nodeTarget ? 'esm' : 'iife',
+  target: nodeTarget ? 'node' : 'browser',
+  minify: !nodeTarget,
+  write: false,
+});
+
+if (!result.success) {
+  const message = result.logs.map((log) => log.message).join('\n');
+  console.error(message || 'Guest script build failed');
+  process.exit(1);
+}
+
+const artifact = result.outputs[0];
+if (!artifact) {
+  console.error('Guest script build produced no output');
+  process.exit(1);
+}
+
+await writeFile(resolve(outfile), await artifact.text());