toolroll 0.9.65 → 0.9.68

package/dist/session-remote.js

@@ -1,86 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { envelopeJson } from './envelope.js';
-import { REMOTE_MESSAGES, reproveRemote } from './operate-remote.js';
-import { SESSION_RESPONSE_BYTES, isSessionResponse } from './session-contract.js';
-import { parseSessionArguments, renderSessionResponse, sessionExitCode, sessionRequestOf } from './session-cli.js';
-import { SessionService } from './session-service.js';
-export function createSessionRunner(options) {
-    const { store } = options;
-    const clock = options.clock ?? (() => new Date());
-    const authorized = (actor, repo) => {
-        const account = store.accountOf(actor.name);
-        return account !== null && account.revokedAt === null && account.generation === actor.generation && store.isInstanceOperator(actor.name)
-            && (repo === undefined || (options.projectAllowed(repo) && options.projects().includes(repo)));
-    };
-    const service = options.workspace === null || store.isDemo() ? null : new SessionService({ workspace: options.workspace, authorized,
-        project: (actor, input) => {
-            const path = realpathSync(input);
-            if (!authorized(actor, path) || !options.projects().includes(path))
-                throw Error('Choose a project already admitted to this installation.');
-            return path;
-        },
-    });
-    return async (principal, argv, files, write) => {
-        const json = argv.includes('--json');
-        const parsed = parseSessionArguments(argv.slice(1), 'server');
-        const operation = 'problem' in parsed ? null : parsed.spec.operation;
-        const command = `session ${operation ?? '(unknown)'}`;
-        let tokenName = null;
-        const record = (outcome, repo, why) => {
-            store.recordAction({ at: clock().toISOString(), actor: principal.account, repo, taskId: null, runId: null, action: `remote command: ${command}`, outcome, source: 'api',
-                detail: `token ${tokenName ?? principal.tokenId}${why === null ? '' : ` · ${why}`}` });
-        };
-        const answer = (response) => {
-            write(json ? envelopeJson({ ...response, command }) : renderSessionResponse(response));
-            return sessionExitCode(response);
-        };
-        const refuse = (spec, reason, message) => {
-            record('refused', null, reason);
-            if (spec === null) {
-                write(json ? envelopeJson({ ok: false, command, reason, message }) : message);
-                return 2;
-            }
-            return answer({ version: 1, operation: spec.operation, ok: false, status: 'rejected', delivery: 'not-sent', retry: spec.mutation ? 'never' : 'safe-read', reason, message, nextActions: [] });
-        };
-        const proved = reproveRemote(store, principal, clock());
-        if (!proved.ok)
-            return refuse('problem' in parsed ? null : parsed.spec, 'unauthenticated', REMOTE_MESSAGES.stale);
-        tokenName = proved.tokenName;
-        if ('problem' in parsed)
-            return refuse(null, 'usage', parsed.problem);
-        const { spec } = parsed;
-        if (spec.mutation && proved.scope !== 'act')
-            return refuse(spec, 'read-only', REMOTE_MESSAGES.read);
-        // A session reaches every project this installation admits: a project-limited token never stands for that.
-        if (principal.projects !== null || !store.isInstanceOperator(principal.account))
-            return refuse(spec, 'all-projects', 'Native sessions need instance operator access to every project. Use a token without a project limit.');
-        const file = parsed.flags['file'];
-        if (file !== undefined && (typeof file !== 'string' || !Object.hasOwn(files, file)))
-            return refuse(spec, 'usage', REMOTE_MESSAGES.files);
-        const validated = sessionRequestOf(parsed, typeof file === 'string' ? files[file] : undefined);
-        if (!validated.ok)
-            return refuse(spec, 'invalid-request', validated.message);
-        if (service === null)
-            return refuse(spec, 'session-unavailable', 'The session owner is not ready.');
-        const repo = 'project' in validated.request && spec.operation === 'start' ? validated.request.project : null;
-        record('requested', repo, null);
-        const uncertain = (reason, message) => {
-            const sessionId = 'sessionId' in validated.request ? validated.request.sessionId : undefined;
-            return { version: 1, operation: spec.operation, ok: false, status: 'uncertain', delivery: 'unknown', retry: 'inspect-first', reason, message,
-                nextActions: [{ operation: sessionId ? 'show' : 'list', label: sessionId ? 'Inspect session' : 'Inspect saved sessions', ...(sessionId ? { sessionId } : {}) }] };
-        };
-        let reply;
-        try {
-            reply = await service.execute({ name: principal.account, generation: principal.generation }, spec.operation, validated.request);
-            if (!isSessionResponse(reply, spec.operation))
-                throw new Error('Invalid owner response');
-            if (Buffer.byteLength(JSON.stringify(reply)) > SESSION_RESPONSE_BYTES)
-                reply = uncertain('response-too-large', 'The owner response is too large to deliver. Inspect saved activity before continuing; this request was not retried.');
-        }
-        catch {
-            reply = uncertain('unconfirmed-response', 'The owner response could not be confirmed. Inspect saved activity before continuing; this request was not retried.');
-        }
-        record(reply.ok ? 'done' : reply.status === 'uncertain' ? 'failed' : 'refused', repo, reply.ok ? null : reply.reason ?? null);
-        return answer(reply);
-    };
-}

package/dist/session-service.d.ts

@@ -1,22 +0,0 @@
-import { CodingWorkspace, type CodingActor } from './coding-workspace.js';
-import { type SessionOperation, type SessionResponse } from './session-contract.js';
-type Options = {
-    workspace: CodingWorkspace;
-    /** Recheck the live account generation and installation-wide operator role. */
-    authorized: (actor: CodingActor, repo?: string) => boolean;
-    /** Resolve only an admitted project. Never accept an arbitrary filesystem path. */
-    project: (actor: CodingActor, project: string) => string;
-};
-/** A narrow projection and operation boundary shared by authenticated adapters.
- * This object never opens a second catalog or starts a competing provider. */
-export declare class SessionService {
-    private readonly options;
-    constructor(options: Options);
-    private authorize;
-    private view;
-    private next;
-    private inspect;
-    private result;
-    execute<O extends SessionOperation>(actor: CodingActor, operation: O, value: unknown): Promise<SessionResponse>;
-}
-export {};

package/dist/session-service.js

@@ -1,157 +0,0 @@
-import { realpathSync } from 'node:fs';
-import { CodingActionError, CodingWorkspace } from './coding-workspace.js';
-import { sessionDescriptor, validateSessionRequest } from './session-contract.js';
-import { savedSessionBrief } from './session-brief.js';
-const mutationMessages = { start: 'Session started.', send: 'Message delivered.', stop: 'Stop requested.', resume: 'Session reconnected.', recover: 'Saved activity reconciled. Inspect the current state before continuing.' };
-const expectedOf = (input) => ({ revision: input.expectedRevision, nativeThreadId: input.expectedThreadId, turnId: input.expectedTurnId });
-/** A narrow projection and operation boundary shared by authenticated adapters.
- * This object never opens a second catalog or starts a competing provider. */
-export class SessionService {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-    authorize(actor, repo) {
-        if (!this.options.authorized(actor, repo))
-            throw new CodingActionError('This operation requires current operator access to the project.', 'rejected');
-    }
-    view(actor, id) {
-        const session = this.options.workspace.get(id, actor);
-        this.authorize(actor, session.repo);
-        return { id: session.id, repo: session.repo, title: session.title, status: session.status,
-            nativeThreadId: session.nativeThreadId, turnId: session.turnId,
-            revision: this.options.workspace.revision(id, actor), branch: session.branch, base: session.base,
-            error: session.error, deliveryReviewRequired: session.deliveryReviewRequired === true, updatedAt: session.updatedAt };
-    }
-    next(session) {
-        if (!session)
-            return [{ operation: 'list', label: 'Inspect sessions' }];
-        const sessionId = session.id;
-        const read = [{ operation: 'show', label: 'Inspect session', sessionId }, { operation: 'changes', label: 'Review changes', sessionId }];
-        if (session.deliveryReviewRequired || session.status === 'needs-input')
-            return [{ operation: 'open-ui', label: session.deliveryReviewRequired ? 'Review uncertain delivery' : 'Answer in the workspace', sessionId }, ...read];
-        if (session.status === 'uncertain')
-            return [{ operation: 'recover', label: 'Reconcile saved activity', sessionId }, ...read];
-        if (session.status === 'interrupted')
-            return [{ operation: 'resume', label: 'Reconnect session', sessionId }, ...read];
-        if (session.status === 'ready')
-            return [{ operation: 'send', label: 'Continue session', sessionId }, ...read];
-        if (session.status === 'working')
-            return [...read, { operation: 'send', label: 'Send a follow-up', sessionId }, { operation: 'stop', label: 'Stop this turn', sessionId }];
-        return read;
-    }
-    inspect(session) {
-        if (!session)
-            return [{ operation: 'list', label: 'Inspect saved sessions' }];
-        const sessionId = session.id;
-        const next = [{ operation: 'show', label: 'Inspect saved session', sessionId }, { operation: 'changes', label: 'Review changes', sessionId }];
-        if (session.deliveryReviewRequired || session.status === 'needs-input')
-            next.push({ operation: 'open-ui', label: session.deliveryReviewRequired ? 'Review uncertain delivery' : 'Answer in the workspace', sessionId });
-        else if (session.status === 'uncertain')
-            next.push({ operation: 'recover', label: 'Reconcile saved activity', sessionId });
-        return next;
-    }
-    result(actor, id, activity = false) {
-        const snapshot = this.options.workspace.snapshotBounded(id, actor), session = this.view(actor, id);
-        // Keep recent context and explicitly label omitted history. Native history
-        // remains authoritative; this bounded transport is not a memory rewrite.
-        let remaining = 1_000_000;
-        const items = [];
-        for (const item of snapshot.items.slice(-100).reverse()) {
-            const bytes = Buffer.byteLength(JSON.stringify(item));
-            if (bytes > remaining)
-                break;
-            items.unshift(item);
-            remaining -= bytes;
-        }
-        const requests = snapshot.requests.slice(0, 50).map(({ id, kind, title, detail }) => ({ id, kind, title: title.slice(0, 1000), detail: detail.slice(0, 8000) }));
-        const next = this.next(session)[0]?.label ?? 'Inspect session';
-        const truncated = snapshot.truncated || items.length !== snapshot.items.length || requests.length !== snapshot.requests.length || snapshot.requests.some(request => request.title.length > 1000 || request.detail.length > 8000);
-        return { session, ...(activity ? { items, requests } : {}), truncated, brief: savedSessionBrief(session, items, next, truncated) };
-    }
-    async execute(actor, operation, value) {
-        const rejected = (message, reason) => ({ version: 1, operation, ok: false, status: 'rejected', delivery: 'not-sent', retry: 'never', message, reason, nextActions: [] });
-        const validation = validateSessionRequest(operation, value);
-        if (!validation.ok)
-            return rejected(validation.message, 'invalid-request');
-        const input = validation.request;
-        const workspace = this.options.workspace;
-        let deliveryMayHaveOccurred = false;
-        try {
-            this.authorize(actor);
-            if (operation === 'list') {
-                const request = input;
-                const repo = request.project ? this.options.project(actor, request.project) : undefined;
-                const page = workspace.listBounded(actor, { limit: request.limit ?? 50, ...(repo === undefined ? {} : { repo }), authorized: project => this.options.authorized(actor, project) });
-                const sessions = page.sessions.map(s => this.view(actor, s.id));
-                return { version: 1, operation, ok: true, status: 'succeeded', delivery: 'confirmed', retry: 'safe-read', message: `${sessions.length} sessions${page.truncated ? ' shown; more may be available' : ''}.`, nextActions: [], result: { sessions, truncated: page.truncated } };
-            }
-            if (operation === 'show' || operation === 'changes') {
-                const { sessionId } = input;
-                this.view(actor, sessionId);
-                const changes = operation === 'changes' ? await workspace.changes(sessionId, actor) : undefined;
-                const result = this.result(actor, sessionId, operation === 'show' && input.view === 'activity');
-                if (changes)
-                    result.changes = changes;
-                return { version: 1, operation, ok: true, status: 'succeeded', delivery: 'confirmed', retry: 'safe-read', message: 'Saved session loaded.', nextActions: this.next(result.session), result };
-            }
-            const request = input;
-            let repo;
-            if (operation === 'start') {
-                repo = realpathSync(this.options.project(actor, request.project));
-                this.authorize(actor, repo);
-            }
-            else
-                this.view(actor, request.sessionId);
-            // Stable field order makes a JSON field-order difference the same request.
-            const fingerprint = JSON.stringify([operation, Object.keys(request).sort().map(k => [k, request[k]]), repo ?? null]);
-            const receipt = await workspace.command(actor, request.key, fingerprint, () => this.authorize(actor, repo), async () => {
-                const sessionId = operation === 'start' ? null : request.sessionId;
-                try {
-                    this.authorize(actor, repo);
-                    if (sessionId) {
-                        this.view(actor, sessionId);
-                        workspace.assertExpected(sessionId, actor, expectedOf(request));
-                    }
-                }
-                catch (error) {
-                    throw error instanceof CodingActionError ? error : new CodingActionError(error instanceof Error ? error.message : 'This session is unavailable.', 'rejected', sessionId ?? undefined);
-                }
-                deliveryMayHaveOccurred = true;
-                if (operation === 'start') {
-                    const start = request;
-                    return (await workspace.start(actor, { repo: repo, title: start.title, prompt: start.prompt, model: start.model ?? null, requestId: start.key })).id;
-                }
-                const expected = expectedOf(request);
-                if (operation === 'send')
-                    await workspace.send(sessionId, actor, request.prompt, request.key, expected);
-                else if (operation === 'stop')
-                    await workspace.stop(sessionId, actor, expected);
-                else if (operation === 'resume')
-                    await workspace.resume(sessionId, actor, expected);
-                else if (operation === 'recover')
-                    await workspace.recover(sessionId, actor, expected);
-                return sessionId;
-            });
-            // A replay reads a prior receipt without performing again. Losing access
-            // or failing to project that result cannot prove the original was unsent.
-            deliveryMayHaveOccurred ||= receipt.status !== 'rejected';
-            const id = receipt.sessionId ?? (operation === 'start' ? undefined : request.sessionId);
-            const result = { ...(id ? this.result(actor, id) : {}), receipt: { key: request.key, status: receipt.status } };
-            const status = receipt.status === 'accepted' ? 'succeeded' : receipt.status === 'pending' && result.session ? 'pending' : receipt.status === 'rejected' ? 'rejected' : 'uncertain';
-            const nextActions = status === 'pending' || status === 'uncertain' ? this.inspect(result.session) : this.next(result.session);
-            if (result.brief && (status === 'pending' || status === 'uncertain'))
-                result.brief = { ...result.brief, nextAction: nextActions[0]?.label ?? 'Inspect saved session' };
-            return { version: 1, operation, ok: status === 'succeeded' || status === 'pending', status,
-                delivery: status === 'rejected' ? 'not-sent' : status === 'uncertain' ? 'unknown' : 'confirmed', retry: 'inspect-first',
-                message: receipt.message ?? (status === 'succeeded' ? mutationMessages[operation] : 'Inspect saved activity before continuing. This request will not be sent again.'),
-                nextActions, result };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'The session operation could not finish.';
-            if (deliveryMayHaveOccurred)
-                return { version: 1, operation, ok: false, status: 'uncertain', delivery: 'unknown', retry: 'inspect-first', message, reason: 'unconfirmed-response', nextActions: [{ operation: 'list', label: 'Inspect saved sessions' }] };
-            return rejected(message, sessionDescriptor(operation)?.mutation ? 'not-admitted' : 'unavailable');
-        }
-    }
-}