offsite 0.0.0 → 0.0.2

package/apps/server/dist/schemes.js

@@ -0,0 +1,262 @@
+export const schemes = [
+    {
+        id: 'one-dark-darker',
+        name: 'One Dark Darker',
+        background: '#15181C',
+        foreground: '#ABB2BF',
+        cursor: '#B3BAC5',
+        selectionBackground: '#3B414D',
+        palette: [
+            '#4A4F5A',
+            '#EE5D69',
+            '#97C775',
+            '#B68353',
+            '#61AFEF',
+            '#C678DD',
+            '#56B6C2',
+            '#CCCCCC',
+            '#616A7B',
+            '#FE808A',
+            '#C2DEAD',
+            '#D1A47A',
+            '#93CFFF',
+            '#E0A8F1',
+            '#82D2DC',
+            '#FFFFFF',
+        ],
+    },
+    {
+        id: 'one-dark-pro',
+        name: 'One Dark Pro',
+        background: '#282C34',
+        foreground: '#ABB2BF',
+        cursor: '#528BFF',
+        selectionBackground: '#41454E',
+        palette: [
+            '#3F4451',
+            '#E05561',
+            '#8CC265',
+            '#D18F52',
+            '#4AA5F0',
+            '#C162DE',
+            '#42B3C2',
+            '#D7DAE0',
+            '#4F5666',
+            '#FF616E',
+            '#A5E075',
+            '#F0A45D',
+            '#4DC4FF',
+            '#DE73FF',
+            '#4CD1E0',
+            '#E6E6E6',
+        ],
+    },
+    {
+        id: 'dracula',
+        name: 'Dracula',
+        background: '#282A36',
+        foreground: '#F8F8F2',
+        cursor: '#F8F8F2',
+        selectionBackground: '#44475A',
+        palette: [
+            '#21222C',
+            '#FF5555',
+            '#50FA7B',
+            '#F1FA8C',
+            '#BD93F9',
+            '#FF79C6',
+            '#8BE9FD',
+            '#F8F8F2',
+            '#6272A4',
+            '#FF6E6E',
+            '#69FF94',
+            '#FFFFA5',
+            '#D6ACFF',
+            '#FF92DF',
+            '#A4FFFF',
+            '#FFFFFF',
+        ],
+    },
+    {
+        id: 'tokyo-night',
+        name: 'Tokyo Night',
+        background: '#1A1B26',
+        foreground: '#C0CAF5',
+        cursor: '#C0CAF5',
+        selectionBackground: '#33467C',
+        palette: [
+            '#15161E',
+            '#F7768E',
+            '#9ECE6A',
+            '#E0AF68',
+            '#7AA2F7',
+            '#BB9AF7',
+            '#7DCFFF',
+            '#A9B1D6',
+            '#414868',
+            '#F7768E',
+            '#9ECE6A',
+            '#E0AF68',
+            '#7AA2F7',
+            '#BB9AF7',
+            '#7DCFFF',
+            '#C0CAF5',
+        ],
+    },
+    {
+        id: 'catppuccin-mocha',
+        name: 'Catppuccin Mocha',
+        background: '#1E1E2E',
+        foreground: '#CDD6F4',
+        cursor: '#F5E0DC',
+        selectionBackground: '#585B70',
+        palette: [
+            '#45475A',
+            '#F38BA8',
+            '#A6E3A1',
+            '#F9E2AF',
+            '#89B4FA',
+            '#F5C2E7',
+            '#94E2D5',
+            '#BAC2DE',
+            '#585B70',
+            '#F38BA8',
+            '#A6E3A1',
+            '#F9E2AF',
+            '#89B4FA',
+            '#F5C2E7',
+            '#94E2D5',
+            '#A6ADC8',
+        ],
+    },
+    {
+        id: 'nord',
+        name: 'Nord',
+        background: '#2E3440',
+        foreground: '#D8DEE9',
+        cursor: '#D8DEE9',
+        selectionBackground: '#434C5E',
+        palette: [
+            '#3B4252',
+            '#BF616A',
+            '#A3BE8C',
+            '#EBCB8B',
+            '#81A1C1',
+            '#B48EAD',
+            '#88C0D0',
+            '#E5E9F0',
+            '#4C566A',
+            '#BF616A',
+            '#A3BE8C',
+            '#EBCB8B',
+            '#81A1C1',
+            '#B48EAD',
+            '#8FBCBB',
+            '#ECEFF4',
+        ],
+    },
+    {
+        id: 'gruvbox-dark',
+        name: 'Gruvbox Dark',
+        background: '#282828',
+        foreground: '#EBDBB2',
+        cursor: '#EBDBB2',
+        selectionBackground: '#504945',
+        palette: [
+            '#282828',
+            '#CC241D',
+            '#98971A',
+            '#D79921',
+            '#458588',
+            '#B16286',
+            '#689D6A',
+            '#A89984',
+            '#928374',
+            '#FB4934',
+            '#B8BB26',
+            '#FABD2F',
+            '#83A598',
+            '#D3869B',
+            '#8EC07C',
+            '#EBDBB2',
+        ],
+    },
+    {
+        id: 'solarized-dark',
+        name: 'Solarized Dark',
+        background: '#002B36',
+        foreground: '#839496',
+        cursor: '#839496',
+        selectionBackground: '#073642',
+        palette: [
+            '#073642',
+            '#DC322F',
+            '#859900',
+            '#B58900',
+            '#268BD2',
+            '#D33682',
+            '#2AA198',
+            '#EEE8D5',
+            '#002B36',
+            '#CB4B16',
+            '#586E75',
+            '#657B83',
+            '#839496',
+            '#6C71C4',
+            '#93A1A1',
+            '#FDF6E3',
+        ],
+    },
+    {
+        id: 'github-dark',
+        name: 'GitHub Dark',
+        background: '#0D1117',
+        foreground: '#E6EDF3',
+        cursor: '#E6EDF3',
+        selectionBackground: '#264F78',
+        palette: [
+            '#484F58',
+            '#FF7B72',
+            '#3FB950',
+            '#D29922',
+            '#58A6FF',
+            '#BC8CFF',
+            '#39C5CF',
+            '#B1BAC4',
+            '#6E7681',
+            '#FFA198',
+            '#56D364',
+            '#E3B341',
+            '#79C0FF',
+            '#D2A8FF',
+            '#56D4DD',
+            '#FFFFFF',
+        ],
+    },
+    {
+        id: 'rose-pine',
+        name: 'Rosé Pine',
+        background: '#191724',
+        foreground: '#E0DEF4',
+        cursor: '#E0DEF4',
+        selectionBackground: '#403D52',
+        palette: [
+            '#26233A',
+            '#EB6F92',
+            '#31748F',
+            '#F6C177',
+            '#9CCFD8',
+            '#C4A7E7',
+            '#EBBCBA',
+            '#E0DEF4',
+            '#6E6A86',
+            '#EB6F92',
+            '#31748F',
+            '#F6C177',
+            '#9CCFD8',
+            '#C4A7E7',
+            '#EBBCBA',
+            '#E0DEF4',
+        ],
+    },
+];

package/apps/server/dist/sessions.js

@@ -0,0 +1,65 @@
+import { deleteSession, forkSession, getSessionMessages, listSessions, renameSession, } from '@anthropic-ai/claude-agent-sdk';
+import { projects } from './projects.js';
+import { runs } from './run.js';
+import { readJson, writeJson } from './storage.js';
+export async function sessions() {
+    const marks = readMarks();
+    const lists = await Promise.all(projects().map(async (project) => (await listSessions({
+        dir: project.path,
+        includeWorktrees: false,
+        includeProgrammatic: false,
+    })).map((item) => ({
+        id: item.sessionId,
+        title: item.summary,
+        cwd: project.path,
+        branch: item.gitBranch ?? null,
+        updatedAt: item.lastModified,
+        pinned: marks.pinned.includes(item.sessionId),
+        archived: marks.archived.includes(item.sessionId),
+    }))));
+    return lists.flat();
+}
+export async function updateSession(id, patch) {
+    if (patch.title !== undefined)
+        await renameSession(id, patch.title);
+    const marks = readMarks();
+    if (patch.pinned !== undefined)
+        marks.pinned = mark(marks.pinned, id, patch.pinned);
+    if (patch.archived !== undefined)
+        marks.archived = mark(marks.archived, id, patch.archived);
+    writeMarks(marks);
+}
+export async function removeSession(id) {
+    const run = runs.get(id);
+    if (run !== undefined) {
+        run.stop();
+        await run.closed;
+    }
+    await deleteSession(id);
+    const marks = readMarks();
+    writeMarks({
+        pinned: mark(marks.pinned, id, false),
+        archived: mark(marks.archived, id, false),
+    });
+}
+export async function fork(sessionId, cwd, messageId) {
+    const disk = await getSessionMessages(sessionId, { dir: cwd });
+    const index = disk.findIndex((item) => item.uuid === messageId);
+    if (index < 0)
+        throw new Error('Cannot fork the session at that point');
+    const result = await forkSession(sessionId, {
+        dir: cwd,
+        upToMessageId: messageId,
+    });
+    return { sessionId: result.sessionId };
+}
+function readMarks() {
+    return (readJson('sessions.json') ?? { pinned: [], archived: [] });
+}
+function writeMarks(marks) {
+    writeJson('sessions.json', marks);
+}
+function mark(ids, id, on) {
+    const rest = ids.filter((item) => item !== id);
+    return on ? [...rest, id] : rest;
+}

package/apps/server/dist/socket.js

@@ -0,0 +1,149 @@
+import { accounts, addAccount, capabilities, removeAccount, updateAccount, } from './claude.js';
+import { configInfo, readConfig, saveConfig } from './config.js';
+import { listFiles, saveUpload } from './files.js';
+import { commit, createPullRequest, gitStatus, push, suggestCommitMessage, workingDiff, } from './git.js';
+import { earlier } from './history.js';
+import { clients } from './hub.js';
+import { addProject, directories, projects, removeProject, updateProject, } from './projects.js';
+import { pushKey, subscribe, unsubscribe } from './push.js';
+import { activity, runs } from './run.js';
+import { open, rewind, send } from './runs.js';
+import { fork, removeSession, sessions, updateSession } from './sessions.js';
+import { listShells } from './terminal/process.js';
+import { busyTerminal, detachTerminal, savePastedImage, terminalInput, terminalRequest, } from './terminal/terminal.js';
+const handlers = {
+    ping: () => null,
+    'config.get': () => configInfo(),
+    'config.save': (params) => saveConfig(params),
+    'projects.list': () => projects(),
+    'projects.add': (params) => addProject(params.path),
+    'projects.update': (params) => updateProject(params.path, params.patch),
+    'projects.remove': (params) => removeProject(params.path),
+    'directories.list': (params) => directories(params.path),
+    'sessions.list': () => sessions(),
+    'sessions.update': async (params) => {
+        await updateSession(params.id, params.patch);
+        return sessions();
+    },
+    'sessions.remove': async (params) => {
+        await removeSession(params.id);
+        return sessions();
+    },
+    'sessions.open': async (params, client) => {
+        await open(client, params.sessionId, params.cwd);
+        return null;
+    },
+    'sessions.earlier': (params) => earlier(params.sessionId, params.cwd, params.before),
+    'sessions.send': async (params, client) => {
+        await send(client, params);
+        return null;
+    },
+    'sessions.unqueue': (params) => {
+        runs.get(params.sessionId)?.unqueue(params.id);
+        return null;
+    },
+    'sessions.interrupt': async (params) => {
+        await runs.get(params.sessionId)?.query.interrupt();
+        return null;
+    },
+    'sessions.configure': async (params) => {
+        await runs.get(params.sessionId)?.configure(params.settings);
+        return null;
+    },
+    'sessions.respond': (params) => {
+        runs
+            .get(params.sessionId)
+            ?.respond(params.requestId, params.decision, params.answers);
+        return null;
+    },
+    'sessions.rewind': (params) => rewind(params),
+    'sessions.fork': (params) => fork(params.sessionId, params.cwd, params.messageId),
+    'accounts.list': () => accounts(),
+    'accounts.add': (params) => {
+        addAccount(params.name, params.configDir);
+        return accounts();
+    },
+    'accounts.update': (params) => {
+        updateAccount(params.id, params.name, params.configDir);
+        return accounts();
+    },
+    'accounts.remove': (params) => {
+        removeAccount(params.id);
+        return accounts();
+    },
+    capabilities: (params) => capabilities(params.accountId, params.cwd),
+    'files.list': (params) => listFiles(params.cwd),
+    'files.upload': (params) => saveUpload(params.name, Buffer.from(params.data, 'base64')),
+    'git.status': (params) => gitStatus(params.cwd),
+    'git.diff': (params) => workingDiff(params.cwd),
+    'git.commit': (params) => commit(params.cwd, params.message),
+    'git.push': (params) => push(params.cwd),
+    'git.pullRequest': (params) => createPullRequest(params.cwd),
+    'git.message': (params) => suggestCommitMessage(params.accountId, params.cwd),
+    'push.key': () => pushKey(),
+    'push.subscribe': (params) => {
+        subscribe(params);
+        return null;
+    },
+    'push.unsubscribe': (params) => {
+        unsubscribe(params.endpoint);
+        return null;
+    },
+    terminal: async (params, client) => {
+        await terminalRequest(client, params);
+        return null;
+    },
+    'terminal.shells': () => listShells(),
+    'terminal.busy': (params) => busyTerminal(params.id),
+    'terminal.paste': (params) => savePastedImage(params.type, Buffer.from(params.data, 'base64')),
+};
+export function connectClient(socket) {
+    const client = {
+        socket,
+        heardAt: Date.now(),
+        opening: null,
+        sessionId: null,
+        send: (message) => socket.send(JSON.stringify(message)),
+    };
+    clients.add(client);
+    client.send({ type: 'activity', activity: activity() });
+    client.send({ type: 'config', config: readConfig() });
+    client.send({ type: 'projects', projects: projects() });
+    socket.on('message', (data, isBinary) => {
+        client.heardAt = Date.now();
+        if (isBinary) {
+            terminalInput(client, data);
+            return;
+        }
+        void answer(client, String(data));
+    });
+    socket.on('error', (error) => console.warn(`a browser connection failed: ${error}`));
+    socket.on('close', () => {
+        clients.delete(client);
+        detachTerminal(client);
+    });
+}
+async function answer(client, text) {
+    let call;
+    try {
+        call = JSON.parse(text);
+    }
+    catch (error) {
+        console.warn(`ignoring a message that is not JSON: ${error}`);
+        return;
+    }
+    try {
+        if (!Object.hasOwn(handlers, call.method))
+            throw new Error(`unknown method ${call.method}`);
+        const handler = handlers[call.method];
+        const result = await handler(call.params, client);
+        client.send({ type: 'reply', id: call.id, result });
+    }
+    catch (error) {
+        client.send({
+            type: 'reply',
+            id: call.id,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}

package/apps/server/dist/storage.js

@@ -0,0 +1,22 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { args } from './args.js';
+export const home = args.dir;
+export function readJson(name) {
+    try {
+        return JSON.parse(readFileSync(path.join(home, name), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export function writeJson(name, value) {
+    const file = path.join(home, name);
+    mkdirSync(home, { recursive: true });
+    writeFileSync(`${file}.tmp`, `${JSON.stringify(value, null, 2)}\n`, {
+        mode: 0o600,
+    });
+    renameSync(`${file}.tmp`, file);
+}

package/apps/server/dist/terminal/alerts.js

@@ -0,0 +1,145 @@
+export const ALERT_DELAY = 500;
+const BELL_GAP = 5000;
+const NOTIFICATION_GAP = 1000;
+const PAYLOAD_LIMIT = 1024;
+const ESC = 0x1b;
+const BEL = 0x07;
+const CAN = 0x18;
+const SUB = 0x1a;
+export class Scanner {
+    title = '';
+    state = 'ground';
+    payload = [];
+    scan(bytes) {
+        let alert = null;
+        let index = 0;
+        while (index < bytes.length) {
+            if (this.state === 'ground') {
+                let offset = index;
+                while (offset < bytes.length &&
+                    bytes[offset] !== ESC &&
+                    bytes[offset] !== BEL)
+                    offset++;
+                if (offset === bytes.length)
+                    break;
+                index = offset;
+            }
+            const found = this.step(bytes[index]);
+            index++;
+            if (found === null)
+                continue;
+            if (found.type === 'bell')
+                alert ??= found;
+            else
+                alert = found;
+        }
+        return alert;
+    }
+    step(byte) {
+        if (byte === CAN || byte === SUB) {
+            this.state = 'ground';
+            return null;
+        }
+        switch (this.state) {
+            case 'ground':
+                if (byte === ESC)
+                    this.state = 'escape';
+                if (byte === BEL)
+                    return { type: 'bell' };
+                return null;
+            case 'escape':
+                if (byte === 0x5d) {
+                    this.payload = [];
+                    this.state = 'osc';
+                }
+                else if ([0x50, 0x58, 0x5e, 0x5f].includes(byte))
+                    this.state = 'text';
+                else if (byte !== ESC)
+                    this.state = 'ground';
+                if (byte === BEL)
+                    return { type: 'bell' };
+                return null;
+            case 'osc':
+                if (byte === BEL) {
+                    this.state = 'ground';
+                    return this.finish();
+                }
+                if (byte === ESC)
+                    this.state = 'oscEscape';
+                else if (this.payload.length < PAYLOAD_LIMIT)
+                    this.payload.push(byte);
+                return null;
+            case 'oscEscape':
+                if (byte === 0x5c) {
+                    this.state = 'ground';
+                    return this.finish();
+                }
+                this.state = 'escape';
+                return this.step(byte);
+            case 'text':
+                if (byte === ESC)
+                    this.state = 'textEscape';
+                return null;
+            case 'textEscape':
+                if (byte === 0x5c) {
+                    this.state = 'ground';
+                    return null;
+                }
+                this.state = 'escape';
+                return this.step(byte);
+        }
+    }
+    finish() {
+        const text = Buffer.from(this.payload).toString('utf8');
+        if (text.startsWith('0;') || text.startsWith('2;')) {
+            this.title = text.slice(2);
+            return null;
+        }
+        if (text.startsWith('9;')) {
+            const body = text.slice(2);
+            const digits = /^\d*/.exec(body)?.[0].length ?? 0;
+            if (digits > 0 && (body.length === digits || body[digits] === ';'))
+                return null;
+            return { type: 'notification', title: '', body };
+        }
+        if (text.startsWith('777;notify;')) {
+            const rest = text.slice('777;notify;'.length);
+            const split = rest.indexOf(';');
+            return split === -1
+                ? { type: 'notification', title: rest, body: '' }
+                : {
+                    type: 'notification',
+                    title: rest.slice(0, split),
+                    body: rest.slice(split + 1),
+                };
+        }
+        return null;
+    }
+}
+export class Alerts {
+    pushedAt = null;
+    bellPending = false;
+    startBell() {
+        if (this.bellPending || this.pushedRecently(BELL_GAP))
+            return false;
+        this.bellPending = true;
+        return true;
+    }
+    finishBell() {
+        if (!this.bellPending)
+            return false;
+        this.bellPending = false;
+        this.pushedAt = Date.now();
+        return true;
+    }
+    startNotification() {
+        this.bellPending = false;
+        if (this.pushedRecently(NOTIFICATION_GAP))
+            return false;
+        this.pushedAt = Date.now();
+        return true;
+    }
+    pushedRecently(gap) {
+        return this.pushedAt !== null && Date.now() - this.pushedAt < gap;
+    }
+}