offsite 0.0.2 → 0.0.4

package/apps/server/dist/protocol.js

@@ -1,20 +0,0 @@
-export const FRAME_INPUT = 0;
-export const FRAME_REPLY = 1;
-export const FRAME_OUTPUT = 2;
-export const FRAME_REPLAY = 3;
-export function encodeFrame(kind, id, data) {
-    const frame = new Uint8Array(5 + data.length);
-    frame[0] = kind;
-    new DataView(frame.buffer).setUint32(1, id);
-    frame.set(data, 5);
-    return frame;
-}
-export function decodeFrame(frame) {
-    if (frame.length < 5)
-        throw new Error('terminal frame is too short');
-    return {
-        kind: frame[0],
-        id: new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(1),
-        data: frame.subarray(5),
-    };
-}

package/apps/server/dist/push.js

@@ -1,152 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { renameSync } from 'node:fs';
-import path from 'node:path';
-import webPush from 'web-push';
-import { home, readJson, writeJson } from './storage.js';
-const pushFile = path.join(home, 'push.json');
-const TITLE_LIMIT = 100;
-const BODY_LIMIT = 500;
-const TIME_TO_LIVE = 15 * 60;
-const SEND_TIMEOUT = 10_000;
-const SUBJECT = 'https://github.com/NazmusSayad/offsite';
-let server = '';
-let active = false;
-export function startPush(address) {
-    server = address;
-    try {
-        const store = readJson('push.json');
-        if (store !== null)
-            track(store);
-    }
-    catch (error) {
-        console.warn(`push notifications are off until a browser turns them on again, could not read ${pushFile}: ${error}`);
-    }
-}
-export function pushActive() {
-    return active;
-}
-export function pushKey() {
-    return { publicKey: read().publicKey };
-}
-export function subscribe(subscription) {
-    const endpoint = new URL(subscription.endpoint);
-    if (endpoint.protocol !== 'https:')
-        throw new Error('the endpoint must be an https URL');
-    update((store) => {
-        store.subscriptions = store.subscriptions.filter((existing) => existing.endpoint !== subscription.endpoint);
-        store.subscriptions.push({
-            endpoint: subscription.endpoint,
-            keys: { p256dh: subscription.keys.p256dh, auth: subscription.keys.auth },
-            server,
-        });
-    });
-    console.log('a browser subscribed to push notifications');
-}
-export function unsubscribe(endpoint) {
-    update((store) => {
-        store.subscriptions = store.subscriptions.filter((existing) => existing.endpoint !== endpoint);
-    });
-    console.log('a browser unsubscribed from push notifications');
-}
-export async function sendPush(message) {
-    let store;
-    try {
-        store = read();
-    }
-    catch (error) {
-        console.error(`could not read push subscriptions: ${error}`);
-        return;
-    }
-    const subscriptions = store.subscriptions.filter(ours);
-    if (subscriptions.length === 0)
-        return;
-    const payload = JSON.stringify({
-        ...message,
-        title: [...message.title].slice(0, TITLE_LIMIT).join(''),
-        body: [...message.body].slice(0, BODY_LIMIT).join(''),
-    });
-    const gone = [];
-    await Promise.all(subscriptions.map(async (subscription) => {
-        try {
-            await webPush.sendNotification(subscription, payload, {
-                vapidDetails: {
-                    subject: SUBJECT,
-                    publicKey: store.publicKey,
-                    privateKey: store.privateKey,
-                },
-                TTL: TIME_TO_LIVE,
-                urgency: 'high',
-                timeout: SEND_TIMEOUT,
-            });
-        }
-        catch (error) {
-            const status = error.statusCode;
-            if (status !== undefined && [401, 403, 404, 410].includes(status)) {
-                console.log(`push subscription ${subscription.endpoint} is gone or was made for another key, removing it`);
-                gone.push(subscription.endpoint);
-                return;
-            }
-            console.warn(`could not send a push to ${subscription.endpoint}: ${error}`);
-        }
-    }));
-    if (gone.length === 0)
-        return;
-    try {
-        update((current) => {
-            current.subscriptions = current.subscriptions.filter((subscription) => !gone.includes(subscription.endpoint));
-        });
-    }
-    catch (error) {
-        console.error(`could not remove gone push subscriptions: ${error}`);
-    }
-}
-function ours(subscription) {
-    return subscription.server === server;
-}
-function track(store) {
-    active = store.subscriptions.some(ours);
-}
-function load() {
-    let store;
-    try {
-        store = readJson('push.json');
-    }
-    catch (error) {
-        if (!(error instanceof SyntaxError))
-            throw error;
-        return replaceCorrupt(error);
-    }
-    if (store === null)
-        return create();
-    if (typeof store.publicKey !== 'string' ||
-        typeof store.privateKey !== 'string' ||
-        !Array.isArray(store.subscriptions))
-        return replaceCorrupt(new Error('it is missing its keys or subscriptions'));
-    return store;
-}
-function replaceCorrupt(error) {
-    const aside = `${pushFile}.corrupt-${randomUUID()}`;
-    renameSync(pushFile, aside);
-    console.warn(`${pushFile} is corrupt, moved it to ${aside} and created a new one: ${error}`);
-    return create();
-}
-function create() {
-    const keys = webPush.generateVAPIDKeys();
-    const store = { ...keys, subscriptions: [] };
-    save(store);
-    return store;
-}
-function save(store) {
-    writeJson('push.json', store);
-}
-function read() {
-    const store = load();
-    track(store);
-    return store;
-}
-function update(change) {
-    const store = load();
-    change(store);
-    save(store);
-    track(store);
-}

package/apps/server/dist/run.js

@@ -1,375 +0,0 @@
-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': {
-                const accountId = this.settings.accountId;
-                if (accountId === null)
-                    throw new Error('Rate limit event for a run without an account');
-                broadcast({
-                    type: 'limits',
-                    accountId,
-                    limits: recordLimit(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

@@ -1,102 +0,0 @@
-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);
-}