@playcraft/cli 0.1.22 → 0.1.24

package/dist/workspace-runtime/main.js

@@ -1,10 +0,0 @@
-import { runWorkspaceRuntimeServe } from '../commands/workspace-runtime.js';
-const flag = process.argv.indexOf('--config');
-const configPath = flag >= 0 ? process.argv[flag + 1] : undefined;
-if (!configPath) {
-    console.error('workspace-runtime: missing --config');
-    process.exitCode = 2;
-}
-else {
-    await runWorkspaceRuntimeServe(configPath);
-}

package/dist/workspace-runtime/persistence/journal.js

@@ -1,355 +0,0 @@
-import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { workspaceRegistrationSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { SqliteWorkerClient } from './sqlite-client.js';
-export const RUNTIME_STATE_FILE = 'runtime-state.sqlite';
-export const LEGACY_JOURNAL_FILE = 'journal.json';
-export const LEGACY_JOURNAL_SENTINEL = 'PLAYCRAFT_RUNTIME_STATE_SQLITE\n';
-export class RuntimeJournal {
-    filePath;
-    legacyPath;
-    client;
-    listeners = new Set();
-    maintenance;
-    engineInfo;
-    epochs = [];
-    readToken = '';
-    inboxPending = 0;
-    locks = new Map();
-    snapshot = emptySnapshot();
-    constructor(stateDir) {
-        this.filePath = join(stateDir, RUNTIME_STATE_FILE);
-        this.legacyPath = join(stateDir, LEGACY_JOURNAL_FILE);
-    }
-    async exclusive(key, action) {
-        const previous = this.locks.get(key) ?? Promise.resolve();
-        let release;
-        const current = new Promise((resolve) => {
-            release = resolve;
-        });
-        this.locks.set(key, current);
-        await previous;
-        try {
-            return await action();
-        }
-        finally {
-            release();
-            if (this.locks.get(key) === current)
-                this.locks.delete(key);
-        }
-    }
-    async load() {
-        await mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
-        const legacy = await readLegacy(this.legacyPath, this.filePath);
-        const started = await SqliteWorkerClient.open(this.filePath, legacy?.value ?? null);
-        this.client = started.client;
-        this.apply(started.opened);
-        if (legacy?.readable)
-            await writeFile(this.legacyPath, LEGACY_JOURNAL_SENTINEL, { mode: 0o600 });
-        this.maintenance = setInterval(() => {
-            void this.client?.request('maintain').catch(() => undefined);
-        }, 30_000);
-        this.maintenance.unref?.();
-    }
-    async close() {
-        if (this.maintenance)
-            clearInterval(this.maintenance);
-        await this.client?.close();
-        this.client = undefined;
-    }
-    engine() {
-        if (!this.engineInfo)
-            throw new Error('sqlite_engine_unavailable');
-        return this.engineInfo;
-    }
-    sourceReadToken() {
-        return this.readToken;
-    }
-    pendingInbox() {
-        return this.inboxPending;
-    }
-    epochsSnapshot() {
-        return this.epochs.map((epoch) => ({ ...epoch }));
-    }
-    onSourceEvent(listener) {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    }
-    getWorkspace(workspaceId) {
-        return this.snapshot.workspaces[workspaceId];
-    }
-    async putWorkspace(binding) {
-        const parsed = workspaceRegistrationSchema.parse(binding);
-        await this.run('upsertRecord', { bucket: 'workspaces', key: parsed.workspaceId, body: parsed });
-    }
-    async forgetWorkspaces() {
-        await this.run('forgetWorkspaces', {});
-    }
-    findSessionCreation(sessionId) {
-        return Object.values(this.snapshot.operations).find((item) => item.kind === 'session.create' && item.sessionId === sessionId);
-    }
-    findTerminalCreation(terminalId) {
-        return Object.values(this.snapshot.operations).find((item) => item.kind === 'terminal.create' && item.terminalId === terminalId);
-    }
-    getOperation(scopeKey) {
-        return this.snapshot.operations[scopeKey];
-    }
-    getOperationById(operationId) {
-        return Object.values(this.snapshot.operations).find((operation) => operation.operationId === operationId);
-    }
-    listOperations() {
-        return Object.entries(this.snapshot.operations).map(([scopeKey, operation]) => ({ scopeKey, operation }));
-    }
-    getReceipt(key) {
-        return this.snapshot.receipts[key];
-    }
-    getSession(sessionId) {
-        return this.snapshot.sessions[sessionId];
-    }
-    listSessions() {
-        return Object.values(this.snapshot.sessions);
-    }
-    getTerminal(terminalId) {
-        return this.snapshot.terminals[terminalId];
-    }
-    listTerminals(workspaceId) {
-        return Object.values(this.snapshot.terminals).filter((item) => !workspaceId || item.workspaceId === workspaceId);
-    }
-    listManagedWrites(workspaceId) {
-        return Object.values(this.snapshot.managedWrites).filter((item) => !workspaceId || item.workspaceId === workspaceId);
-    }
-    getManagedWrite(writeId) {
-        return this.snapshot.managedWrites[writeId];
-    }
-    async putManagedWrite(record) {
-        await this.run('upsertRecord', { bucket: 'managed_writes', key: record.writeId, body: record });
-    }
-    getWorkspaceDependencies(workspaceId) {
-        return this.snapshot.workspaceDependencies[workspaceId];
-    }
-    listWorkspaceDependencies() {
-        return Object.values(this.snapshot.workspaceDependencies);
-    }
-    async putWorkspaceDependencies(record) {
-        await this.run('upsertRecord', {
-            bucket: 'workspace_dependencies',
-            key: record.workspaceId,
-            body: record,
-        });
-    }
-    fileRevisions(workspaceId) {
-        return { ...(workspaceId ? this.snapshot.workspaceFileRevisions[workspaceId] ?? {} : this.snapshot.fileRevisions) };
-    }
-    fileRevision(path, workspaceId) {
-        return this.fileRevisions(workspaceId)[path]?.revision ?? 0;
-    }
-    destroyed() {
-        return this.snapshot.destroyed;
-    }
-    lastSourceSequence() {
-        return this.snapshot.lastSourceSequence;
-    }
-    acceptedLeaseFence() {
-        return this.snapshot.acceptedLeaseFence;
-    }
-    storedRuntimeEpoch() {
-        return this.snapshot.runtimeEpoch;
-    }
-    executionGroup() {
-        return { ...this.snapshot.executionGroup };
-    }
-    getApproval(sessionId, approvalId) {
-        return this.snapshot.approvals[`${sessionId}:${approvalId}`];
-    }
-    listApprovals() {
-        return Object.values(this.snapshot.approvals);
-    }
-    async putApproval(approval) {
-        await this.run('upsertRecord', { bucket: 'approvals', key: `${approval.sessionId}:${approval.approvalId}`, body: approval });
-    }
-    async noteExecutionGroup(group) {
-        await this.run('noteExecutionGroup', { group });
-    }
-    async writeExecutionEpoch(input) {
-        await this.run('writeExecutionEpoch', input);
-    }
-    async setExecutionStopConfirmed(stopConfirmed) {
-        await this.run('setStopConfirmed', { stopConfirmed });
-    }
-    async bindRuntime(input) {
-        await this.run('bindRuntime', input);
-    }
-    listEvents(afterSequence = 0) {
-        return Object.values(this.snapshot.events)
-            .filter((event) => event.source.sourceSequence > afterSequence)
-            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence || left.source.runtimeEpoch - right.source.runtimeEpoch);
-    }
-    readSourcePage(input) {
-        const epoch = this.epochs.find((item) => item.runtime_id === input.runtimeId && item.generation === input.generation && item.runtime_epoch === input.runtimeEpoch);
-        const retainedFrom = epoch?.retained_from ?? 1;
-        const highWater = epoch?.local_durable_through ?? 0;
-        const coveredThrough = input.after;
-        if (retainedRangeHasGap(retainedFrom, coveredThrough)) {
-            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
-        }
-        const matched = Object.values(this.snapshot.events)
-            .filter((event) => event.source.runtimeId === input.runtimeId &&
-            event.source.generation === input.generation &&
-            event.source.runtimeEpoch === input.runtimeEpoch &&
-            event.source.sourceSequence > input.after)
-            .sort((left, right) => left.source.sourceSequence - right.source.sourceSequence);
-        const first = matched[0];
-        if (first && first.source.sourceSequence > input.after + 1) {
-            return { ok: false, code: 'source_gap', retainedFrom, highWater, coveredThrough, ...identity(input) };
-        }
-        const events = matched.slice(0, input.limit ?? 100);
-        const nextAfter = events.at(-1)?.source.sourceSequence ?? input.after;
-        return { ok: true, events, retainedFrom, highWater, nextAfter, ...identity(input) };
-    }
-    async allocateSourceEvent(input) {
-        const result = await this.run('allocateEvent', input);
-        const event = result.committedEvents?.[0];
-        if (!event)
-            throw new Error('source_event_missing');
-        return event;
-    }
-    async commitSourceIdentity(event) {
-        await this.run('commitIdentity', { event: pendingSourceEventSchema.parse(event) });
-    }
-    async ingestNative(input) {
-        const result = await this.run('ingest', input);
-        return result.committedEvents ?? [];
-    }
-    async bindTurn(input) {
-        const result = await this.run('bindTurn', input);
-        return result.committedEvents ?? [];
-    }
-    async acknowledgeSource(ack) {
-        await this.run('ack', sourceAckSchema.parse(ack));
-    }
-    async createReplayPin(input) {
-        const result = await this.run('createPin', { identity: input, ttlMs: input.ttlMs });
-        return replayPinResultSchema.parse(result.pin);
-    }
-    async deleteReplayPin(pinId) {
-        await this.run('deletePin', { pinId });
-    }
-    async reclaimSourceEvents(minRetainMs = 0) {
-        await this.run('reclaim', { minRetainMs });
-    }
-    async putOperation(scopeKey, operation) {
-        const parsed = operationRecordSchema.parse(operation);
-        await this.run('putOperation', { scopeKey, operation: parsed });
-        return this.snapshot.operations[scopeKey] ?? parsed;
-    }
-    async putSession(binding) {
-        await this.run('upsertRecord', { bucket: 'sessions', key: binding.sessionId, body: binding });
-    }
-    async putTerminal(record) {
-        const parsed = terminalRecordSchema.parse(record);
-        await this.run('upsertRecord', { bucket: 'terminals', key: parsed.terminalId, body: parsed });
-        return parsed;
-    }
-    async putFileRevision(path, record, workspaceId) {
-        if (workspaceId) {
-            await this.run('upsertRecord', { bucket: `workspace_files:${workspaceId}`, key: path, body: record });
-            return;
-        }
-        await this.run('upsertRecord', { bucket: 'file_revisions', key: path, body: record });
-    }
-    async markDestroyed() {
-        await this.run('setDestroyed', {});
-    }
-    async replaceSessions(sessions) {
-        await this.run('replaceBucket', {
-            bucket: 'sessions',
-            entries: sessions.map((session) => ({ key: session.sessionId, body: session })),
-        });
-    }
-    async setAcceptedLeaseFence(value) {
-        await this.run('setAcceptedFence', { value });
-    }
-    async putReceipt(receipt, sourceSequence) {
-        const parsed = sourceEventReceiptSchema.parse(receipt);
-        await this.run('upsertRecord', { bucket: 'receipts', key: sourceEventKey(parsed.source), body: parsed });
-        void sourceSequence;
-    }
-    async appendEvent(event) {
-        const parsed = pendingSourceEventSchema.parse(event);
-        await this.commitSourceIdentity(parsed);
-        return this.snapshot.events[sourceEventKey(parsed.source)] ?? parsed;
-    }
-    async run(type, payload) {
-        if (!this.client)
-            throw new Error('sqlite_not_open');
-        const result = await this.client.request(type, payload);
-        this.apply(result);
-        for (const event of result.committedEvents ?? []) {
-            for (const listener of this.listeners)
-                listener(event);
-        }
-        return result;
-    }
-    apply(dump) {
-        const group = dump.snapshot.executionGroup;
-        this.snapshot = {
-            ...emptySnapshot(),
-            ...dump.snapshot,
-            executionGroup: {
-                stopConfirmed: group?.stopConfirmed === true,
-                replaced: group?.replaced === true,
-                pid: group?.pid,
-                startedAt: group?.startedAt,
-                previousPid: group?.previousPid,
-            },
-        };
-        this.epochs = dump.epochs ?? [];
-        this.readToken = dump.sourceReadToken ?? this.readToken;
-        this.inboxPending = dump.pendingInbox ?? 0;
-        if (dump.engine)
-            this.engineInfo = dump.engine;
-    }
-}
-async function readLegacy(legacyPath, sqlitePath) {
-    if (!existsSync(legacyPath))
-        return null;
-    const text = await readFile(legacyPath, 'utf8');
-    if (text.startsWith(LEGACY_JOURNAL_SENTINEL.trim())) {
-        if (!existsSync(sqlitePath))
-            throw new Error('runtime_state_missing');
-        return null;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new Error('legacy_journal_unreadable');
-    }
-    if (!existsSync(`${legacyPath}.bak`))
-        await copyFile(legacyPath, `${legacyPath}.bak`);
-    return { value, readable: true };
-}
-function identity(input) {
-    return { runtimeId: input.runtimeId, generation: input.generation, runtimeEpoch: input.runtimeEpoch };
-}
-function emptySnapshot() {
-    return {
-        workspaces: {},
-        workspaceFileRevisions: {},
-        operations: {},
-        receipts: {},
-        events: {},
-        sessions: {},
-        terminals: {},
-        fileRevisions: {},
-        approvals: {},
-        managedWrites: {},
-        workspaceDependencies: {},
-        executionGroup: { stopConfirmed: false, replaced: false },
-        lastSourceSequence: 0,
-        acceptedLeaseFence: 0,
-        destroyed: false,
-    };
-}

package/dist/workspace-runtime/persistence/sqlite-client.js

@@ -1,61 +0,0 @@
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { Worker } from 'node:worker_threads';
-export class SqliteWorkerClient {
-    nextId = 1;
-    pending = new Map();
-    chain = Promise.resolve();
-    worker;
-    constructor(worker) {
-        this.worker = worker;
-        worker.on('message', (message) => {
-            const waiter = this.pending.get(message.id);
-            if (!waiter)
-                return;
-            this.pending.delete(message.id);
-            if (message.ok)
-                waiter.resolve(message.result);
-            else
-                waiter.reject(new Error(message.error || 'sqlite_worker_failed'));
-        });
-        worker.on('error', (error) => {
-            for (const waiter of this.pending.values())
-                waiter.reject(error);
-            this.pending.clear();
-        });
-    }
-    static async open(filePath, legacy) {
-        const client = new SqliteWorkerClient(new Worker(workerUrl(), { execArgv: [], env: { ...process.env, NODE_OPTIONS: '' } }));
-        try {
-            const opened = await client.request('open', { filePath, legacy });
-            return { client, opened };
-        }
-        catch (error) {
-            await client.close().catch(() => undefined);
-            throw error;
-        }
-    }
-    request(type, payload) {
-        const run = this.chain.then(() => this.send(type, payload));
-        this.chain = run.then(() => undefined, () => undefined);
-        return run;
-    }
-    async close() {
-        await this.request('close', {}).catch(() => undefined);
-        await this.worker.terminate();
-    }
-    send(type, payload) {
-        const id = this.nextId;
-        this.nextId += 1;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve: (value) => resolve(value), reject });
-            this.worker.postMessage({ id, type, payload });
-        });
-    }
-}
-function workerUrl() {
-    const compiled = new URL('./sqlite-worker.js', import.meta.url);
-    if (existsSync(fileURLToPath(compiled)))
-        return compiled;
-    return new URL('./sqlite-worker.ts', import.meta.url);
-}