@ours.network/fleet 0.19.0-nightly.1 → 0.19.0-nightly.3

package/dist/rooms-tasks/config.d.ts

@@ -0,0 +1,15 @@
+import type { RoomsConfig, TasksConfig, RoomTemplatesConfig } from './types.js';
+export declare class RoomsTasksConfigError extends Error {
+    readonly path: string;
+    constructor(path: string, message: string);
+}
+export declare function fingerprint(invite: string): string;
+export declare function validateRoomsConfig(raw: unknown, vars: Record<string, string>, path: string): RoomsConfig & {
+    _invite?: {
+        value: string;
+        fingerprint: string;
+    };
+};
+export declare function validateTasksConfig(raw: unknown, path: string): TasksConfig;
+export declare function validateRoomTemplatesConfig(raw: unknown, path: string): RoomTemplatesConfig;
+export declare const FLEET_D_ALLOWED_KEYS: readonly ["roles", "rooms", "room_templates", "tasks"];

package/dist/rooms-tasks/config.js

@@ -0,0 +1,171 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, TEMPLATE_OVERRIDE_KEYS as TOK, } from './types.js';
+import { BUILTIN_TEMPLATES } from './templates.js';
+const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const CID_RE = /^[0-9a-fA-F]{64}$/;
+export class RoomsTasksConfigError extends Error {
+    path;
+    constructor(path, message) {
+        super(`${path}: ${message}`);
+        this.path = path;
+    }
+}
+function rejectUnknown(obj, allowed, path, section) {
+    const bad = Object.keys(obj).filter(k => !allowed.includes(k));
+    if (bad.length)
+        throw new RoomsTasksConfigError(path, `${section} has unknown key(s) ${bad.join(', ')}; allowed: ${allowed.join(', ')}`);
+}
+export function fingerprint(invite) {
+    return createHash('sha256').update(invite.trim()).digest('hex');
+}
+function resolveInvite(owner, vars, path) {
+    const inline = owner.public_invite;
+    const file = owner.public_invite_file;
+    if (inline && file)
+        throw new RoomsTasksConfigError(path, 'rooms.owner: exactly one of public_invite or public_invite_file');
+    if (!inline && !file)
+        return undefined;
+    let raw;
+    if (file) {
+        const resolved = file.replace(/\$\{(\w+)\}/g, (m, k) => (k in vars ? String(vars[k]) : m));
+        if (!existsSync(resolved))
+            throw new RoomsTasksConfigError(path, `rooms.owner.public_invite_file: not found: ${resolved}`);
+        raw = readFileSync(resolved, 'utf8').trim();
+    }
+    else {
+        raw = inline;
+    }
+    if (!raw)
+        throw new RoomsTasksConfigError(path, 'rooms.owner: invite is empty');
+    return { value: raw, fingerprint: fingerprint(raw) };
+}
+export function validateRoomsConfig(raw, vars, path) {
+    if (!isPlainObject(raw))
+        throw new RoomsTasksConfigError(path, 'rooms: must be a mapping');
+    rejectUnknown(raw, RK, path, 'rooms');
+    const provider = raw.provider ?? 'cowork';
+    if (provider !== 'cowork')
+        throw new RoomsTasksConfigError(path, `rooms.provider: unsupported '${provider}'; allowed: cowork`);
+    let cowork;
+    if (raw.cowork !== undefined) {
+        if (!isPlainObject(raw.cowork))
+            throw new RoomsTasksConfigError(path, 'rooms.cowork: must be a mapping');
+        rejectUnknown(raw.cowork, RCK, path, 'rooms.cowork');
+        cowork = { config: raw.cowork.config };
+    }
+    if (!isPlainObject(raw.owner))
+        throw new RoomsTasksConfigError(path, 'rooms.owner: required and must be a mapping');
+    rejectUnknown(raw.owner, ROK, path, 'rooms.owner');
+    const ownerProvider = raw.owner.provider ?? 'messenger-server';
+    const expectedCid = raw.owner.expected_cid;
+    if (!expectedCid)
+        throw new RoomsTasksConfigError(path, 'rooms.owner.expected_cid: required');
+    if (!CID_RE.test(expectedCid))
+        throw new RoomsTasksConfigError(path, 'rooms.owner.expected_cid: must be exactly 64 hexadecimal characters');
+    const ownerRole = raw.owner.role ?? 'Owner';
+    const invite = resolveInvite(raw.owner, vars, path);
+    const owner = {
+        provider: ownerProvider,
+        expected_cid: expectedCid.toLowerCase(),
+        role: ownerRole,
+        ...(raw.owner.public_invite ? { public_invite: '[REDACTED]' } : {}),
+        ...(raw.owner.public_invite_file ? { public_invite_file: raw.owner.public_invite_file } : {}),
+    };
+    let defaults;
+    if (raw.defaults !== undefined) {
+        if (!isPlainObject(raw.defaults))
+            throw new RoomsTasksConfigError(path, 'rooms.defaults: must be a mapping');
+        rejectUnknown(raw.defaults, RDK, path, 'rooms.defaults');
+        defaults = {
+            template: raw.defaults.template,
+            attach_owner: raw.defaults.attach_owner,
+            close_when_task_done: raw.defaults.close_when_task_done,
+        };
+    }
+    return { provider, cowork, owner, defaults, _invite: invite };
+}
+export function validateTasksConfig(raw, path) {
+    if (!isPlainObject(raw))
+        throw new RoomsTasksConfigError(path, 'tasks: must be a mapping');
+    rejectUnknown(raw, TK, path, 'tasks');
+    const createMode = raw.create_mode;
+    if (createMode !== undefined && createMode !== 'start' && createMode !== 'backlog')
+        throw new RoomsTasksConfigError(path, `tasks.create_mode: must be 'start' or 'backlog'`);
+    if (raw.close_room_on_done !== undefined && typeof raw.close_room_on_done !== 'boolean')
+        throw new RoomsTasksConfigError(path, 'tasks.close_room_on_done: must be a boolean');
+    if (raw.retain_completed_for !== undefined && typeof raw.retain_completed_for !== 'string')
+        throw new RoomsTasksConfigError(path, 'tasks.retain_completed_for: must be a duration string');
+    return {
+        default_room_template: raw.default_room_template,
+        create_mode: createMode,
+        close_room_on_done: raw.close_room_on_done,
+        retain_completed_for: raw.retain_completed_for,
+    };
+}
+export function validateRoomTemplatesConfig(raw, path) {
+    if (!isPlainObject(raw))
+        throw new RoomsTasksConfigError(path, 'room_templates: must be a mapping');
+    const result = {};
+    for (const [name, tplRaw] of Object.entries(raw)) {
+        if (!/^[a-z0-9_-]+$/.test(name))
+            throw new RoomsTasksConfigError(path, `room_templates: invalid template name '${name}' (allowed: [a-z0-9_-])`);
+        if (!isPlainObject(tplRaw))
+            throw new RoomsTasksConfigError(path, `room_templates.${name}: must be a mapping`);
+        rejectUnknown(tplRaw, [...TPK, 'name'], path, `room_templates.${name}`);
+        const isBuiltinOverride = BUILTIN_TEMPLATES.some(b => b.name === name);
+        if (isBuiltinOverride && !tplRaw.override_builtin)
+            throw new RoomsTasksConfigError(path, `room_templates.${name}: overrides built-in template; set override_builtin: true and bump version`);
+        const version = tplRaw.version;
+        if (version === undefined || !Number.isInteger(version) || version < 1)
+            throw new RoomsTasksConfigError(path, `room_templates.${name}.version: required positive integer`);
+        if (!tplRaw.description || typeof tplRaw.description !== 'string')
+            throw new RoomsTasksConfigError(path, `room_templates.${name}.description: required string`);
+        if (!Array.isArray(tplRaw.members) || !tplRaw.members.length)
+            throw new RoomsTasksConfigError(path, `room_templates.${name}.members: required non-empty array`);
+        const members = tplRaw.members.map((m, i) => {
+            if (!isPlainObject(m))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}]: must be a mapping`);
+            rejectUnknown(m, TMK, path, `room_templates.${name}.members[${i}]`);
+            if (!m.slot || typeof m.slot !== 'string')
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].slot: required string`);
+            if (!m.role || typeof m.role !== 'string')
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role: required string`);
+            if (!Number.isInteger(m.count) || m.count < 1)
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].count: required positive integer`);
+            if (!m.role_ref || typeof m.role_ref !== 'string')
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role_ref: required string`);
+            if (m.overrides !== undefined) {
+                if (!isPlainObject(m.overrides))
+                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].overrides: must be a mapping`);
+                rejectUnknown(m.overrides, TOK, path, `room_templates.${name}.members[${i}].overrides`);
+            }
+            return {
+                slot: m.slot,
+                role: m.role,
+                count: m.count,
+                role_ref: m.role_ref,
+                overrides: m.overrides,
+            };
+        });
+        let room;
+        if (tplRaw.room !== undefined) {
+            if (!isPlainObject(tplRaw.room))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.room: must be a mapping`);
+            room = {
+                quiet_membership: tplRaw.room.quiet_membership,
+                anonymous: tplRaw.room.anonymous,
+            };
+        }
+        result[name] = {
+            name,
+            version: version,
+            description: tplRaw.description,
+            room,
+            contract: tplRaw.contract,
+            members,
+        };
+    }
+    return result;
+}
+export const FLEET_D_ALLOWED_KEYS = ['roles', 'rooms', 'room_templates', 'tasks'];

package/dist/rooms-tasks/cowork-adapter.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Typed client for the ours-cowork v1 private management-socket protocol.
+ *
+ * Cowork owns room state. Fleet only invokes the versioned JSON RPC exposed
+ * by Cowork's Unix socket and projects the response into orchestration data.
+ */
+import type { Socket } from 'node:net';
+export interface CoworkRoomCreateResult {
+    room_id: string;
+    identity_name: string;
+    identity_cid: string;
+}
+export interface CoworkInviteAcceptResult {
+    seat_cid: string;
+    seat_state: 'pending' | 'active';
+}
+export interface CoworkInviteResult {
+    invite: string;
+    min_accepts: number;
+}
+export interface CoworkSeatInfo {
+    identity_cid: string;
+    role: string;
+    seat_state: 'pending' | 'active' | 'removed';
+}
+export interface CoworkRoomInfo {
+    room_id: string;
+    identity_name: string;
+    identity_cid: string;
+    room_name: string;
+    state: 'provisioning' | 'active' | 'closing' | 'closed';
+    seats: CoworkSeatInfo[];
+    goal?: string;
+    briefing?: string;
+}
+export interface CoworkAdapter {
+    available(): Promise<boolean>;
+    createRoom(opts: {
+        room_name: string;
+        goal: string;
+        briefing: string;
+        quiet_membership?: boolean;
+        anonymous?: boolean;
+    }): Promise<CoworkRoomCreateResult>;
+    acceptInvite(roomId: string, invite: string, opts: {
+        role: string;
+        expected_cid: string;
+    }): Promise<CoworkInviteAcceptResult>;
+    issueInvite(roomId: string, opts: {
+        role: string;
+        min_accepts: number;
+    }): Promise<CoworkInviteResult>;
+    getRoom(roomId: string): Promise<CoworkRoomInfo | undefined>;
+    listRooms(): Promise<CoworkRoomInfo[]>;
+    closeRoom(roomId: string): Promise<void>;
+    getSeats(roomId: string): Promise<CoworkSeatInfo[]>;
+    recoverRoom(roomId: string): Promise<CoworkRoomInfo>;
+}
+export declare class CoworkUnavailableError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+export declare class CoworkProtocolError extends Error {
+    readonly operation: string;
+    readonly code: string;
+    constructor(operation: string, message: string, code?: string, options?: ErrorOptions);
+}
+export interface CoworkAdapterOptions {
+    configPath?: string;
+    socketPath?: string;
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    connect?: (path: string) => Socket;
+}
+/** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
+export declare function resolveCoworkSocketPath(options?: CoworkAdapterOptions): string;
+export declare function createCoworkAdapter(options?: CoworkAdapterOptions): CoworkAdapter;

package/dist/rooms-tasks/cowork-adapter.js

@@ -0,0 +1,272 @@
+/**
+ * Typed client for the ours-cowork v1 private management-socket protocol.
+ *
+ * Cowork owns room state. Fleet only invokes the versioned JSON RPC exposed
+ * by Cowork's Unix socket and projects the response into orchestration data.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { createConnection } from 'node:net';
+const RPC_VERSION = 1;
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
+export class CoworkUnavailableError extends Error {
+    constructor(message = 'Cowork management socket is not reachable', options) {
+        super(message, options);
+        this.name = 'CoworkUnavailableError';
+    }
+}
+export class CoworkProtocolError extends Error {
+    operation;
+    code;
+    constructor(operation, message, code = 'protocol_error', options) {
+        super(`cowork ${operation}: ${message}`, options);
+        this.operation = operation;
+        this.code = code;
+        this.name = 'CoworkProtocolError';
+    }
+}
+function object(value, operation, label) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new CoworkProtocolError(operation, `${label} must be an object`);
+    return value;
+}
+function string(value, operation, label) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new CoworkProtocolError(operation, `${label} must be a non-empty string`);
+    return value;
+}
+function text(value, operation, label) {
+    if (typeof value !== 'string')
+        throw new CoworkProtocolError(operation, `${label} must be a string`);
+    return value;
+}
+function roomState(value, operation) {
+    if (value !== 'provisioning' && value !== 'active' && value !== 'closing' && value !== 'closed')
+        throw new CoworkProtocolError(operation, 'room state is invalid');
+    return value;
+}
+function seatState(value, operation) {
+    if (value !== 'pending' && value !== 'active' && value !== 'removed')
+        throw new CoworkProtocolError(operation, 'seat state is invalid');
+    return value;
+}
+function projectSeat(value, operation) {
+    const seat = object(value, operation, 'seat');
+    return {
+        identity_cid: string(seat.identity, operation, 'seat.identity'),
+        role: string(seat.role, operation, 'seat.role'),
+        seat_state: seatState(seat.state, operation),
+    };
+}
+function projectRoom(value, operation) {
+    const room = object(value, operation, 'room');
+    if (!Array.isArray(room.seats))
+        throw new CoworkProtocolError(operation, 'room.seats must be an array');
+    const mission = room.mission === undefined ? undefined : object(room.mission, operation, 'room.mission');
+    return {
+        room_id: string(room.room_id, operation, 'room.room_id'),
+        identity_name: string(room.identity_name, operation, 'room.identity_name'),
+        // Cowork reserves an empty CID only for its durable packet_pending
+        // recovery sentinel; list/show must preserve that recoverable state.
+        identity_cid: text(room.identity_cid, operation, 'room.identity_cid'),
+        room_name: string(room.room_name, operation, 'room.room_name'),
+        state: roomState(room.state, operation),
+        seats: room.seats.map((seat) => projectSeat(seat, operation)),
+        ...(typeof mission?.goal === 'string' ? { goal: mission.goal } : {}),
+        ...(typeof mission?.briefing === 'string' ? { briefing: mission.briefing } : {}),
+    };
+}
+/** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
+export function resolveCoworkSocketPath(options = {}) {
+    if (options.socketPath)
+        return resolve(options.socketPath);
+    const env = options.env ?? process.env;
+    const home = options.home ?? homedir();
+    const configuredPath = options.configPath ?? env.OURS_COWORK_CONFIG;
+    const configPath = resolve(configuredPath ?? join(home, '.ours-cowork', 'config.json'));
+    let stateDir = resolve(home, '.ours-cowork');
+    if (existsSync(configPath)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(configPath, 'utf8'));
+        }
+        catch (error) {
+            throw new CoworkProtocolError('config', `malformed config at ${configPath}`, 'invalid_config', { cause: error });
+        }
+        const config = object(parsed, 'config', 'config');
+        if (config.version !== 1 || typeof config.stateDir !== 'string' || !config.stateDir)
+            throw new CoworkProtocolError('config', `invalid Cowork v1 config at ${configPath}`, 'invalid_config');
+        stateDir = resolve(config.stateDir);
+    }
+    else if (configuredPath !== undefined) {
+        throw new CoworkProtocolError('config', `configured Cowork config does not exist: ${configPath}`, 'invalid_config');
+    }
+    if (env.OURS_COWORK_STATE_DIR)
+        stateDir = resolve(env.OURS_COWORK_STATE_DIR);
+    return join(stateDir, 'management.sock');
+}
+function rpcCall(socketPath, method, params, timeoutMs, connect) {
+    const id = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const request = `${JSON.stringify({ version: RPC_VERSION, id, method, params })}\n`;
+    return new Promise((resolveCall, rejectCall) => {
+        const socket = connect(socketPath);
+        let bytes = '';
+        let size = 0;
+        let settled = false;
+        let connected = false;
+        const finishError = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            rejectCall(error);
+        };
+        const timer = setTimeout(() => finishError(new CoworkUnavailableError(connected ? 'Cowork did not answer the management socket' : 'Cowork management socket is not reachable')), timeoutMs);
+        socket.setEncoding('utf8');
+        socket.once('connect', () => {
+            connected = true;
+            socket.write(request);
+        });
+        socket.on('data', (chunk) => {
+            if (settled)
+                return;
+            const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+            size += Buffer.byteLength(text);
+            if (size > MAX_RESPONSE_BYTES) {
+                finishError(new CoworkProtocolError(method, 'response exceeded 4 MiB'));
+                return;
+            }
+            bytes += text;
+            const newline = bytes.indexOf('\n');
+            if (newline < 0)
+                return;
+            if (bytes.slice(newline + 1).trim() !== '') {
+                finishError(new CoworkProtocolError(method, 'daemon returned more than one response'));
+                return;
+            }
+            let response;
+            try {
+                response = object(JSON.parse(bytes.slice(0, newline)), method, 'RPC response');
+            }
+            catch (error) {
+                finishError(error instanceof CoworkProtocolError
+                    ? error : new CoworkProtocolError(method, 'daemon returned malformed JSON', 'protocol_error', { cause: error }));
+                return;
+            }
+            if (response.version !== RPC_VERSION || response.id !== id
+                || (Object.hasOwn(response, 'error') === Object.hasOwn(response, 'result'))) {
+                finishError(new CoworkProtocolError(method, 'daemon returned an invalid RPC response'));
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (Object.hasOwn(response, 'error')) {
+                const error = object(response.error, method, 'RPC error');
+                rejectCall(new CoworkProtocolError(method, typeof error.message === 'string' ? error.message : 'unknown RPC error', typeof error.code === 'string' ? error.code : 'rpc_error'));
+            }
+            else {
+                resolveCall(response.result);
+            }
+        });
+        socket.once('end', () => {
+            if (!settled)
+                finishError(new CoworkProtocolError(method, 'daemon closed without a complete response'));
+        });
+        socket.once('error', (error) => {
+            if (!settled)
+                finishError(new CoworkUnavailableError(error.code === 'EACCES' || error.code === 'EPERM'
+                    ? 'Cowork management socket access denied' : 'Cowork management socket is not reachable', { cause: error }));
+        });
+    });
+}
+export function createCoworkAdapter(options = {}) {
+    const socketPath = resolveCoworkSocketPath(options);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const connect = options.connect ?? ((path) => createConnection(path));
+    const call = (method, params) => rpcCall(socketPath, method, params, timeoutMs, connect);
+    return {
+        async available() {
+            try {
+                await call('room.list', {});
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async createRoom(opts) {
+            const result = projectRoom(await call('room.create', {
+                name: opts.room_name,
+                goal: opts.goal,
+                briefing: opts.briefing,
+                ...(opts.quiet_membership === undefined ? {} : { quiet_membership: opts.quiet_membership }),
+                ...(opts.anonymous === undefined ? {} : { anonymous: opts.anonymous }),
+            }), 'room.create');
+            if (!result.identity_cid)
+                throw new CoworkProtocolError('room.create', 'created room did not establish an identity CID');
+            return { room_id: result.room_id, identity_name: result.identity_name, identity_cid: result.identity_cid };
+        },
+        async acceptInvite(roomId, invite, opts) {
+            const receipt = object(await call('room.accept', {
+                room_id: roomId,
+                role: opts.role,
+                invite,
+                expected_cid: opts.expected_cid,
+            }), 'room.accept', 'receipt');
+            const state = seatState(receipt.state, 'room.accept');
+            if (state === 'removed')
+                throw new CoworkProtocolError('room.accept', 'accepted seat cannot be removed');
+            return {
+                seat_cid: string(receipt.identity, 'room.accept', 'receipt.identity'),
+                seat_state: state,
+            };
+        },
+        async issueInvite(roomId, opts) {
+            const receipt = object(await call('room.invite', {
+                room_id: roomId,
+                mode: 'public',
+                role: opts.role,
+                min_accepts: opts.min_accepts,
+            }), 'room.invite', 'receipt');
+            const invite = object(receipt.invite, 'room.invite', 'receipt.invite');
+            return {
+                invite: string(receipt.blob, 'room.invite', 'receipt.blob'),
+                min_accepts: typeof invite.min_accepts === 'number'
+                    ? invite.min_accepts : opts.min_accepts,
+            };
+        },
+        async getRoom(roomId) {
+            try {
+                return projectRoom(await call('room.show', { room_id: roomId }), 'room.show');
+            }
+            catch (error) {
+                if (error instanceof CoworkProtocolError && error.code === 'not_found')
+                    return undefined;
+                throw error;
+            }
+        },
+        async listRooms() {
+            const result = await call('room.list', {});
+            if (!Array.isArray(result))
+                throw new CoworkProtocolError('room.list', 'result must be an array');
+            return result.map((room) => projectRoom(room, 'room.list'));
+        },
+        async closeRoom(roomId) { await call('room.close', { room_id: roomId }); },
+        async getSeats(roomId) {
+            const result = await call('room.participants', { room_id: roomId });
+            if (!Array.isArray(result))
+                throw new CoworkProtocolError('room.participants', 'result must be an array');
+            return result.map((seat) => projectSeat(seat, 'room.participants'));
+        },
+        async recoverRoom(roomId) {
+            // Cowork performs packet/state reconciliation during daemon recovery.
+            // Its `room.recover` RPC is specifically invite-receipt recovery, so a
+            // Fleet reconciliation pass must read `room.show`, not mutate invites.
+            return projectRoom(await call('room.show', { room_id: roomId }), 'room.show');
+        },
+    };
+}

package/dist/rooms-tasks/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './templates.js';
+export * from './config.js';
+export * from './task-state.js';
+export * from './room-state.js';
+export * from './cowork-adapter.js';
+export { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

package/dist/rooms-tasks/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './templates.js';
+export * from './config.js';
+export * from './task-state.js';
+export * from './room-state.js';
+export * from './cowork-adapter.js';
+export { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

package/dist/rooms-tasks/room-state.d.ts

@@ -0,0 +1,23 @@
+import type { RoomOrchestrationRecord, RoomOrchestrationState, SagaPhase, RoomMemberSeat, ProvisioningDetail } from './types.js';
+export declare const roomsDir: () => string;
+export declare class RoomStateError extends Error {
+}
+export interface CreateRoomInput {
+    room_id: string;
+    room_name: string;
+    room_identity_cid?: string;
+    task_id?: string;
+    template_snapshot?: import('./types.js').TemplateSnapshot;
+}
+export declare function createRoomRecord(input: CreateRoomInput): RoomOrchestrationRecord;
+export declare function getRoomRecord(id: string): RoomOrchestrationRecord | undefined;
+export declare function listRoomRecords(filter?: {
+    state?: RoomOrchestrationState | RoomOrchestrationState[];
+}): RoomOrchestrationRecord[];
+export declare function advanceSaga(id: string, phase: SagaPhase, stepIndex?: number, detail?: ProvisioningDetail): RoomOrchestrationRecord;
+export declare function setSagaError(id: string, error: string, hint?: string, detail?: ProvisioningDetail): RoomOrchestrationRecord;
+export declare function setRoomIdentity(id: string, roomIdentityCid: string): RoomOrchestrationRecord;
+export declare function setOwnerSeat(id: string, ownerSeatCid: string, inviteFingerprint: string): RoomOrchestrationRecord;
+export declare function updateMemberSeats(id: string, seats: RoomMemberSeat[]): RoomOrchestrationRecord;
+export declare function activateRoom(id: string): RoomOrchestrationRecord;
+export declare function closeRoom(id: string): RoomOrchestrationRecord;