offsite 0.0.0 → 0.0.1

package/apps/server/dist/run.js

@@ -0,0 +1,371 @@
+import { randomUUID } from 'node:crypto';
+import { query, } from '@anthropic-ai/claude-agent-sdk';
+import { claudeOptions, recordLimit } from './claude.js';
+import { toContext, toMessage } from './content.js';
+import { broadcast, publish } from './hub.js';
+const IDLE_LIMIT = 10 * 60 * 1000;
+const imageTypes = ['image/png', 'image/jpeg', 'image/gif', 'image/webp'];
+export const runs = new Map();
+export function activity() {
+    const result = {};
+    for (const run of runs.values())
+        result[run.sessionId] = {
+            running: run.running,
+            waiting: run.pending.size > 0,
+        };
+    return result;
+}
+export function broadcastActivity() {
+    broadcast({ type: 'activity', activity: activity() });
+}
+export class Run {
+    sessionId;
+    messages = [];
+    pending = new Map();
+    query;
+    closed;
+    resumeAt;
+    queue = [];
+    settings;
+    context = null;
+    running = false;
+    inbox = [];
+    wake = null;
+    idleTimer;
+    stopping = false;
+    constructor(options) {
+        this.sessionId = options.sessionId;
+        this.resumeAt = options.resumeAt;
+        this.settings = options.settings;
+        const settings = options.settings;
+        this.query = query({
+            prompt: this.input(),
+            options: {
+                ...claudeOptions(settings.accountId, options.cwd),
+                ...(options.resume
+                    ? { resume: options.sessionId }
+                    : { sessionId: options.sessionId }),
+                ...(options.resumeAt === null
+                    ? {}
+                    : { resumeSessionAt: options.resumeAt }),
+                enableFileCheckpointing: true,
+                ...(settings.permissionMode === null
+                    ? {}
+                    : { permissionMode: settings.permissionMode }),
+                ...(settings.model === null ? {} : { model: settings.model }),
+                ...(settings.effort === null ? {} : { effort: settings.effort }),
+                allowDangerouslySkipPermissions: true,
+                includePartialMessages: true,
+                canUseTool: (toolName, input, context) => this.ask({
+                    toolName,
+                    input,
+                    title: context.title ?? null,
+                    suggestions: context.suggestions ?? [],
+                    signal: context.signal,
+                }),
+            },
+        });
+        runs.set(this.sessionId, this);
+        this.closed = this.read();
+    }
+    submit(prompt, delivery) {
+        if (!this.running) {
+            this.push(prompt, undefined);
+            return;
+        }
+        switch (delivery) {
+            case 'steer':
+                this.push(prompt, 'next');
+                return;
+            case 'queue':
+                this.queue = [...this.queue, { id: randomUUID(), prompt }];
+                this.publishQueue();
+        }
+    }
+    unqueue(id) {
+        this.queue = this.queue.filter((item) => item.id !== id);
+        this.publishQueue();
+    }
+    async configure(settings) {
+        if (settings.model !== this.settings.model)
+            await this.query.setModel(settings.model ?? undefined);
+        if (settings.effort !== this.settings.effort)
+            await this.query.applyFlagSettings({ effortLevel: settings.effort });
+        if (settings.permissionMode !== null &&
+            settings.permissionMode !== this.settings.permissionMode)
+            await this.query.setPermissionMode(settings.permissionMode);
+        this.updateSettings({
+            ...settings,
+            accountId: this.settings.accountId,
+            permissionMode: settings.permissionMode ?? this.settings.permissionMode,
+        });
+    }
+    respond(requestId, decision, answers) {
+        const pending = this.pending.get(requestId);
+        if (pending === undefined)
+            return;
+        const input = pending.request.input;
+        switch (decision) {
+            case 'allow':
+                this.settle(requestId, {
+                    behavior: 'allow',
+                    updatedInput: answers === null ? input : { ...input, answers },
+                });
+                return;
+            case 'always':
+                this.settle(requestId, {
+                    behavior: 'allow',
+                    updatedInput: input,
+                    updatedPermissions: pending.suggestions,
+                });
+                return;
+            case 'deny':
+                this.settle(requestId, {
+                    behavior: 'deny',
+                    message: 'The user rejected this action',
+                    interrupt: true,
+                });
+        }
+    }
+    stop() {
+        this.stopping = true;
+        runs.delete(this.sessionId);
+        this.query.close();
+    }
+    push(prompt, priority) {
+        clearTimeout(this.idleTimer);
+        for (const image of prompt.images)
+            if (!imageTypes.includes(image.mediaType))
+                throw new Error(`${image.mediaType} images are not supported`);
+        const uuid = randomUUID();
+        this.inbox.push({
+            type: 'user',
+            message: {
+                role: 'user',
+                content: [
+                    ...prompt.images.map((image) => ({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: image.mediaType,
+                            data: image.data,
+                        },
+                    })),
+                    ...(prompt.text === ''
+                        ? []
+                        : [{ type: 'text', text: prompt.text }]),
+                ],
+            },
+            parent_tool_use_id: null,
+            uuid,
+            ...(priority === undefined ? {} : { priority }),
+        });
+        this.wake?.();
+        this.add({
+            type: 'user',
+            uuid,
+            time: Date.now(),
+            content: [
+                ...prompt.images.map((image) => ({ type: 'image', ...image })),
+                ...(prompt.text === ''
+                    ? []
+                    : [{ type: 'text', text: prompt.text }]),
+            ],
+            parent: null,
+        });
+        this.running = true;
+        broadcastActivity();
+    }
+    async refreshContext() {
+        this.context = toContext(await this.query.getContextUsage());
+        publish(this.sessionId, {
+            type: 'context',
+            sessionId: this.sessionId,
+            context: this.context,
+        });
+    }
+    async *input() {
+        while (true) {
+            const next = this.inbox.shift();
+            if (next !== undefined) {
+                yield next;
+                continue;
+            }
+            await new Promise((resolve) => {
+                this.wake = resolve;
+            });
+        }
+    }
+    async read() {
+        try {
+            for await (const message of this.query)
+                this.receive(message);
+        }
+        catch (error) {
+            if (!this.stopping)
+                this.add(notice(error instanceof Error ? error.message : String(error)));
+        }
+        clearTimeout(this.idleTimer);
+        for (const id of this.pending.keys())
+            this.settle(id, { behavior: 'deny', message: 'Session ended' });
+        if (runs.get(this.sessionId) === this)
+            runs.delete(this.sessionId);
+        this.running = false;
+        broadcastActivity();
+    }
+    receive(message) {
+        switch (message.type) {
+            case 'assistant':
+                this.add(toMessage('assistant', message, Date.now()));
+                if (message.error === 'rate_limit')
+                    this.add(notice('This account hit its usage limit. Pick another account below and send again.'));
+                return;
+            case 'user':
+                if (message.isSynthetic)
+                    return;
+                this.add(toMessage('user', { ...message, uuid: message.uuid ?? randomUUID() }, Date.now()));
+                return;
+            case 'stream_event':
+                if (message.parent_tool_use_id === null &&
+                    message.event.type === 'content_block_delta' &&
+                    message.event.delta.type === 'text_delta')
+                    publish(this.sessionId, {
+                        type: 'delta',
+                        sessionId: this.sessionId,
+                        text: message.event.delta.text,
+                    });
+                return;
+            case 'rate_limit_event':
+                broadcast({
+                    type: 'limits',
+                    accountId: this.settings.accountId,
+                    limits: recordLimit(this.settings.accountId, message.rate_limit_info),
+                });
+                return;
+            case 'result':
+                if (message.subtype !== 'success')
+                    this.add(notice(message.errors.join('\n') || message.subtype));
+                this.finishTurn();
+                this.refreshContext().catch((error) => console.error(error));
+                return;
+            case 'system':
+                switch (message.subtype) {
+                    case 'init':
+                        this.updateSettings({
+                            ...this.settings,
+                            permissionMode: message.permissionMode,
+                        });
+                        return;
+                    case 'status':
+                        if (message.permissionMode !== undefined)
+                            this.updateSettings({
+                                ...this.settings,
+                                permissionMode: message.permissionMode,
+                            });
+                        return;
+                    case 'compact_boundary':
+                        this.add({
+                            type: 'notice',
+                            uuid: message.uuid,
+                            time: Date.now(),
+                            text: 'Conversation compacted',
+                            isError: false,
+                        });
+                        return;
+                    case 'local_command_output':
+                        this.add({
+                            type: 'notice',
+                            uuid: message.uuid,
+                            time: Date.now(),
+                            text: message.content,
+                            isError: false,
+                        });
+                }
+        }
+    }
+    finishTurn() {
+        const [next, ...rest] = this.queue;
+        if (next !== undefined) {
+            this.queue = rest;
+            this.publishQueue();
+            this.push(next.prompt, undefined);
+            return;
+        }
+        this.running = false;
+        broadcastActivity();
+        this.idleTimer = setTimeout(() => {
+            if (!this.running && this.pending.size === 0)
+                this.stop();
+        }, IDLE_LIMIT);
+    }
+    ask(options) {
+        const request = {
+            id: randomUUID(),
+            toolName: options.toolName,
+            input: options.input,
+            title: options.title,
+            canAlwaysAllow: options.suggestions.length > 0,
+        };
+        return new Promise((resolve) => {
+            this.pending.set(request.id, {
+                request,
+                suggestions: options.suggestions,
+                resolve,
+            });
+            publish(this.sessionId, {
+                type: 'request',
+                sessionId: this.sessionId,
+                request,
+            });
+            broadcastActivity();
+            options.signal.addEventListener('abort', () => this.settle(request.id, { behavior: 'deny', message: 'Cancelled' }));
+        });
+    }
+    settle(requestId, result) {
+        const pending = this.pending.get(requestId);
+        if (pending === undefined)
+            return;
+        this.pending.delete(requestId);
+        pending.resolve(result);
+        publish(this.sessionId, {
+            type: 'requestDone',
+            sessionId: this.sessionId,
+            requestId,
+        });
+        broadcastActivity();
+    }
+    add(message) {
+        if (this.messages.some((item) => item.uuid === message.uuid))
+            return;
+        this.messages.push(message);
+        publish(this.sessionId, {
+            type: 'message',
+            sessionId: this.sessionId,
+            message,
+        });
+    }
+    updateSettings(settings) {
+        this.settings = settings;
+        publish(this.sessionId, {
+            type: 'settings',
+            sessionId: this.sessionId,
+            settings,
+        });
+    }
+    publishQueue() {
+        publish(this.sessionId, {
+            type: 'queue',
+            sessionId: this.sessionId,
+            queue: this.queue,
+        });
+    }
+}
+function notice(text) {
+    return {
+        type: 'notice',
+        uuid: randomUUID(),
+        time: Date.now(),
+        text,
+        isError: true,
+    };
+}

package/apps/server/dist/runs.js

@@ -0,0 +1,102 @@
+import { randomUUID } from 'node:crypto';
+import { statSync } from 'node:fs';
+import { getSessionMessages } from '@anthropic-ai/claude-agent-sdk';
+import { history } from './history.js';
+import { publish } from './hub.js';
+import { Run, runs } from './run.js';
+export function stopAll() {
+    for (const run of runs.values())
+        run.stop();
+}
+export async function rewind(request) {
+    const sessionId = request.sessionId;
+    if (runs.get(sessionId)?.running === true)
+        throw new Error('Stop Claude before rewinding');
+    const run = runFor(sessionId, request.cwd, request.settings);
+    let result = null;
+    if (request.code) {
+        const files = await run.query.rewindFiles(request.messageId, {
+            dryRun: request.dryRun,
+        });
+        if (!files.canRewind)
+            throw new Error(files.error ?? 'The files cannot be restored');
+        result = {
+            files: files.filesChanged ?? [],
+            insertions: files.insertions ?? 0,
+            deletions: files.deletions ?? 0,
+        };
+    }
+    if (request.dryRun || !request.conversation)
+        return result;
+    const disk = await getSessionMessages(sessionId, { dir: request.cwd });
+    const index = disk.findIndex((item) => item.uuid === request.messageId);
+    if (index < 1)
+        throw new Error('Cannot rewind the conversation to that point');
+    run.stop();
+    await run.closed;
+    new Run({
+        sessionId,
+        cwd: request.cwd,
+        resume: true,
+        resumeAt: disk[index - 1].uuid,
+        settings: request.settings,
+    });
+    publish(sessionId, await history(sessionId, request.cwd));
+    return result;
+}
+export async function open(client, sessionId, cwd) {
+    client.opening = sessionId;
+    const event = await history(sessionId, cwd);
+    if (client.opening !== sessionId)
+        return;
+    client.sessionId = sessionId;
+    client.send(event);
+}
+export async function send(client, request) {
+    if (!statSync(request.cwd, { throwIfNoEntry: false })?.isDirectory())
+        throw new Error(`${request.cwd} is not a folder`);
+    if (request.sessionId === null) {
+        const sessionId = randomUUID();
+        const run = new Run({
+            sessionId,
+            cwd: request.cwd,
+            resume: false,
+            resumeAt: null,
+            settings: request.settings,
+        });
+        client.opening = sessionId;
+        client.sessionId = sessionId;
+        client.send({ type: 'started', sessionId, cwd: request.cwd });
+        run.submit(request.prompt, request.delivery);
+        return;
+    }
+    const existing = runs.get(request.sessionId);
+    if (existing !== undefined &&
+        !existing.running &&
+        (await changedElsewhere(existing, request.cwd)))
+        existing.stop();
+    const run = runFor(request.sessionId, request.cwd, request.settings);
+    if (run === existing)
+        await run.configure(request.settings);
+    else
+        await open(client, request.sessionId, request.cwd);
+    run.submit(request.prompt, request.delivery);
+}
+function runFor(sessionId, cwd, settings) {
+    const run = runs.get(sessionId);
+    if (run !== undefined && run.settings.accountId === settings.accountId)
+        return run;
+    if (run !== undefined) {
+        if (run.running)
+            throw new Error('Wait for this turn to finish before switching accounts');
+        run.stop();
+    }
+    return new Run({ sessionId, cwd, resume: true, resumeAt: null, settings });
+}
+async function changedElsewhere(run, cwd) {
+    if (run.messages.length === 0)
+        return false;
+    const history = await getSessionMessages(run.sessionId, { dir: cwd });
+    const last = history.at(-1)?.uuid;
+    return last !== undefined && !run.messages.some((item) => item.uuid === last);
+}