offsite 0.0.0 → 0.0.2

package/apps/server/dist/files.js

@@ -0,0 +1,50 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { git } from './git.js';
+import { home } from './storage.js';
+const FILE_LIMIT = 20_000;
+const skipped = new Set(['node_modules', '.git', 'dist', 'target', '.next']);
+export async function listFiles(cwd) {
+    try {
+        const { stdout } = await git(cwd, [
+            'ls-files',
+            '--cached',
+            '--others',
+            '--exclude-standard',
+        ]);
+        return stdout.split('\n').filter(Boolean).slice(0, FILE_LIMIT);
+    }
+    catch {
+        return walk(cwd);
+    }
+}
+export function saveUpload(name, data) {
+    const dir = path.join(home, 'uploads', randomUUID());
+    mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, path.basename(name));
+    writeFileSync(file, data);
+    return file;
+}
+function walk(root) {
+    const files = [];
+    const pending = [''];
+    while (pending.length > 0 && files.length < FILE_LIMIT) {
+        const dir = pending.pop() ?? '';
+        let entries;
+        try {
+            entries = readdirSync(path.join(root, dir), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const relative = dir === '' ? entry.name : `${dir}/${entry.name}`;
+            if (entry.isDirectory() && !skipped.has(entry.name))
+                pending.push(relative);
+            if (entry.isFile())
+                files.push(relative);
+        }
+    }
+    return files;
+}

package/apps/server/dist/git.js

@@ -0,0 +1,133 @@
+import { execFile } from 'node:child_process';
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { claudeOptions } from './claude.js';
+const DIFF_LIMIT = 80_000;
+const UNTRACKED_LIMIT = 100;
+const NEW_FILE_LIMIT = 256 * 1024;
+export async function gitStatus(cwd) {
+    let output;
+    try {
+        output = await git(cwd, ['status', '--porcelain=v2', '--branch']);
+    }
+    catch {
+        return null;
+    }
+    const status = {
+        branch: null,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        changed: 0,
+    };
+    for (const line of output.stdout.split('\n').filter(Boolean)) {
+        const [marker, key, ...rest] = line.split(' ');
+        if (marker !== '#')
+            status.changed++;
+        else if (key === 'branch.head')
+            status.branch = rest[0] === '(detached)' ? null : rest[0];
+        else if (key === 'branch.upstream')
+            status.upstream = rest[0];
+        else if (key === 'branch.ab') {
+            status.ahead = Number(rest[0]);
+            status.behind = -Number(rest[1]);
+        }
+    }
+    return status;
+}
+export async function commit(cwd, message) {
+    if (message.trim() === '')
+        throw new Error('Write a commit message first');
+    await git(cwd, ['add', '--all']);
+    await git(cwd, ['commit', '--message', message]);
+    return gitStatus(cwd);
+}
+export async function push(cwd) {
+    const status = await gitStatus(cwd);
+    if (status === null)
+        throw new Error(`${cwd} is not a git repository`);
+    if (status.upstream === null)
+        await git(cwd, ['push', '--set-upstream', 'origin', 'HEAD']);
+    else
+        await git(cwd, ['push']);
+    return gitStatus(cwd);
+}
+export async function createPullRequest(cwd) {
+    const { stdout } = await promisify(execFile)('gh', ['pr', 'create', '--fill'], { cwd });
+    const url = stdout.trim().split('\n').at(-1);
+    if (url === undefined)
+        throw new Error('gh did not return a pull request URL');
+    return { url };
+}
+export async function suggestCommitMessage(accountId, cwd) {
+    const diff = (await workingDiff(cwd)).slice(0, DIFF_LIMIT);
+    if (diff === '')
+        throw new Error('There is nothing to commit');
+    const conversation = query({
+        prompt: `Write a git commit message for this diff. Reply with only the message: a short summary line, optionally followed by a blank line and a brief body.\n\n${diff}`,
+        options: {
+            ...claudeOptions(accountId, cwd),
+            systemPrompt: 'You write concise git commit messages.',
+            tools: [],
+            model: 'haiku',
+            maxTurns: 1,
+            persistSession: false,
+        },
+    });
+    for await (const message of conversation) {
+        if (message.type !== 'result')
+            continue;
+        if (message.subtype !== 'success')
+            throw new Error(message.errors.join('\n'));
+        if (message.is_error)
+            throw new Error(message.result);
+        return { message: message.result.trim() };
+    }
+    throw new Error('Claude did not reply');
+}
+export async function workingDiff(cwd) {
+    try {
+        await git(cwd, ['rev-parse', '--is-inside-work-tree']);
+    }
+    catch {
+        throw new Error(`${cwd} is not a git repository`);
+    }
+    const tracked = await git(cwd, [
+        'diff',
+        'HEAD',
+        '--no-color',
+        '--no-ext-diff',
+    ]);
+    const untracked = await git(cwd, [
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+    ]);
+    const added = untracked.stdout
+        .split('\n')
+        .filter(Boolean)
+        .slice(0, UNTRACKED_LIMIT)
+        .map((file) => newFilePatch(cwd, file));
+    return [tracked.stdout, ...added].join('');
+}
+export function git(cwd, args) {
+    return promisify(execFile)('git', args, {
+        cwd,
+        maxBuffer: 64 * 1024 * 1024,
+    });
+}
+function newFilePatch(cwd, file) {
+    const header = `diff --git a/${file} b/${file}\nnew file\n--- /dev/null\n+++ b/${file}\n`;
+    const full = path.join(cwd, file);
+    if (statSync(full).size > NEW_FILE_LIMIT)
+        return `${header}Binary or large file\n`;
+    const content = readFileSync(full, 'utf8');
+    if (content.includes('\0'))
+        return `${header}Binary or large file\n`;
+    const lines = content.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    return `${header}@@ -0,0 +1,${lines.length} @@\n${lines.map((line) => `+${line}\n`).join('')}`;
+}

package/apps/server/dist/history.js

@@ -0,0 +1,137 @@
+import { readdir, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { getSessionMessages, getSubagentMessages, } from '@anthropic-ai/claude-agent-sdk';
+import { contextTokens, toMessage } from './content.js';
+import { runs } from './run.js';
+const projectsDir = path.join(os.homedir(), '.claude', 'projects');
+async function sessionEntries(sessionId) {
+    for (const dir of await readdir(projectsDir)) {
+        let text;
+        try {
+            text = await readFile(path.join(projectsDir, dir, `${sessionId}.jsonl`), 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        return text.split('\n').flatMap((line) => {
+            const entry = parseLine(line);
+            return entry !== null && typeof entry.type === 'string'
+                ? [{ ...entry, type: entry.type }]
+                : [];
+        });
+    }
+    return [];
+}
+function messageTimes(entries) {
+    const times = new Map();
+    for (const entry of entries)
+        if (typeof entry.uuid === 'string' && typeof entry.timestamp === 'string')
+            times.set(entry.uuid, Date.parse(entry.timestamp));
+    return times;
+}
+function compactedBefore(entries, uuid) {
+    if (uuid === undefined)
+        return null;
+    const start = entries.findIndex((entry) => entry.uuid === uuid);
+    const index = entries.findLastIndex((entry, position) => position < start &&
+        entry.type === 'system' &&
+        entry.subtype === 'compact_boundary');
+    return index < 0 ? null : index;
+}
+function parseLine(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function mainMessages(disk, times) {
+    return disk.flatMap((item) => item.type === 'system' || item.parent_tool_use_id !== null
+        ? []
+        : [toMessage(item.type, item, times.get(item.uuid) ?? null)]);
+}
+export async function history(sessionId, cwd) {
+    const run = runs.get(sessionId);
+    const [disk, entries] = await Promise.all([
+        getSessionMessages(sessionId, { dir: cwd }),
+        sessionEntries(sessionId),
+    ]);
+    const resumeAt = run?.resumeAt ?? null;
+    const kept = resumeAt === null
+        ? disk
+        : disk.slice(0, disk.findIndex((item) => item.uuid === resumeAt) + 1);
+    const messages = mainMessages(kept, messageTimes(entries));
+    messages.push(...(await subagentMessages(sessionId, cwd, messages)));
+    const seen = new Set(messages.map((item) => item.uuid));
+    const last = kept.findLast((item) => item.type === 'assistant' && item.parent_tool_use_id === null);
+    const tokens = last === undefined ? null : contextTokens(last.message);
+    return {
+        type: 'history',
+        sessionId,
+        messages: [
+            ...messages,
+            ...(run?.messages.filter((item) => !seen.has(item.uuid)) ?? []),
+        ],
+        requests: [...(run?.pending.values() ?? [])].map((item) => item.request),
+        queue: run?.queue ?? [],
+        settings: run?.settings ?? null,
+        context: run?.context ??
+            (tokens === null
+                ? null
+                : { tokens, window: null, model: null, categories: [], sections: [] }),
+        before: compactedBefore(entries, disk[0]?.uuid),
+    };
+}
+export async function earlier(sessionId, cwd, before) {
+    const entries = await sessionEntries(sessionId);
+    const kept = entries.slice(0, before);
+    const disk = await getSessionMessages(sessionId, {
+        sessionStore: { append: () => Promise.resolve(), load: async () => kept },
+    });
+    const messages = mainMessages(disk, messageTimes(entries));
+    messages.push(...(await subagentMessages(sessionId, cwd, messages)));
+    messages.push({
+        type: 'notice',
+        uuid: `compacted:${before}`,
+        time: null,
+        text: 'Conversation compacted',
+        isError: false,
+    });
+    return { messages, before: compactedBefore(entries, disk[0]?.uuid) };
+}
+async function subagentMessages(sessionId, cwd, messages) {
+    const agents = new Set(messages.flatMap((message) => message.type === 'assistant'
+        ? message.content.flatMap((block) => block.type === 'tool_use' &&
+            (block.name === 'Agent' || block.name === 'Task')
+            ? [block.id]
+            : [])
+        : []));
+    const launches = messages.flatMap((message) => message.type === 'user'
+        ? message.content.flatMap((block) => {
+            if (block.type !== 'tool_result' || !agents.has(block.toolUseId))
+                return [];
+            const agentId = /agentId: (\w+)/.exec(block.content
+                .map((item) => (item.type === 'text' ? item.text : ''))
+                .join('\n'))?.[1];
+            return agentId === undefined
+                ? []
+                : [{ agentId, parent: block.toolUseId }];
+        })
+        : []);
+    const loaded = await Promise.all(launches.map(async (launch) => {
+        const disk = await getSubagentMessages(sessionId, launch.agentId, {
+            dir: cwd,
+        });
+        const items = disk.flatMap((item) => item.type === 'system'
+            ? []
+            : [
+                toMessage(item.type, { ...item, parent_tool_use_id: launch.parent }, null),
+            ]);
+        return [...items, ...(await subagentMessages(sessionId, cwd, items))];
+    }));
+    return loaded.flat();
+}

package/apps/server/dist/hub.js

@@ -0,0 +1,10 @@
+export const clients = new Set();
+export function publish(sessionId, event) {
+    for (const client of clients)
+        if (client.sessionId === sessionId)
+            client.send(event);
+}
+export function broadcast(event) {
+    for (const client of clients)
+        client.send(event);
+}

package/apps/server/dist/main.js

@@ -0,0 +1,64 @@
+import { createReadStream, existsSync, statSync } from 'node:fs';
+import { createServer } from 'node:http';
+import path from 'node:path';
+import { WebSocketServer } from 'ws';
+import { args } from './args.js';
+import { findClaude } from './claude.js';
+import { startPush } from './push.js';
+import { stopAll } from './runs.js';
+import { connectClient } from './socket.js';
+const contentTypes = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.ico': 'image/x-icon',
+    '.json': 'application/json',
+    '.webmanifest': 'application/manifest+json',
+    '.woff2': 'font/woff2',
+};
+const port = Number(args.port);
+if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    console.error(`invalid port ${args.port}`);
+    process.exit(1);
+}
+if (findClaude() === null) {
+    console.error('could not find claude on PATH; install Claude Code first');
+    process.exit(1);
+}
+const publicDir = path.join(import.meta.dirname, '..', '..', 'web', 'dist');
+const server = createServer((request, response) => {
+    const url = new URL(request.url ?? '/', 'http://localhost');
+    serveFile(url.pathname, response);
+});
+const sockets = new WebSocketServer({ noServer: true });
+server.on('upgrade', (request, socket, head) => {
+    const url = new URL(request.url ?? '/', 'http://localhost');
+    if (url.pathname === '/ws')
+        sockets.handleUpgrade(request, socket, head, connectClient);
+    else
+        socket.destroy();
+});
+server.listen(port, args.host, () => {
+    startPush(`${args.host}:${port}`);
+    console.log(`offsite is running at http://${args.host}:${port}`);
+});
+process.on('SIGINT', () => {
+    stopAll();
+    process.exit(0);
+});
+function serveFile(pathname, response) {
+    const requested = path.join(publicDir, path.normalize(pathname));
+    const file = requested.startsWith(publicDir + path.sep) &&
+        statSync(requested, { throwIfNoEntry: false })?.isFile()
+        ? requested
+        : path.join(publicDir, 'index.html');
+    if (!existsSync(file)) {
+        response.statusCode = 404;
+        response.end('web app not built; run pnpm build');
+        return;
+    }
+    response.setHeader('content-type', contentTypes[path.extname(file)] ?? 'application/octet-stream');
+    createReadStream(file).pipe(response);
+}

package/apps/server/dist/projects.js

@@ -0,0 +1,92 @@
+import { readdir, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { db } from './db.js';
+import { broadcast } from './hub.js';
+const LOGO_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/gif',
+    'image/webp',
+    'image/svg+xml',
+    'image/x-icon',
+    'image/vnd.microsoft.icon',
+];
+const LOGO_LIMIT = 512 * 1024;
+export function projects() {
+    return db
+        .prepare('SELECT path, name, logo FROM projects')
+        .all()
+        .map(toProject);
+}
+export async function addProject(input) {
+    const folder = path.resolve(expandHome(input.trim()));
+    if (!(await stat(folder)).isDirectory())
+        throw new Error(`${folder} is not a folder`);
+    db.prepare('INSERT OR IGNORE INTO projects (path, name, logo) VALUES (?, ?, NULL)').run(folder, path.basename(folder) || folder);
+    publish();
+    const project = projects().find((item) => item.path === folder);
+    if (project === undefined)
+        throw new Error(`Could not add ${folder}`);
+    return project;
+}
+export function updateProject(folder, patch) {
+    if (patch.name !== undefined) {
+        const name = patch.name.trim();
+        if (name === '')
+            throw new Error('Project name cannot be empty');
+        db.prepare('UPDATE projects SET name = ? WHERE path = ?').run(name, folder);
+    }
+    if (patch.logo !== undefined) {
+        if (patch.logo !== null)
+            checkLogo(patch.logo);
+        db.prepare('UPDATE projects SET logo = ? WHERE path = ?').run(patch.logo, folder);
+    }
+    publish();
+    return null;
+}
+export function removeProject(folder) {
+    db.prepare('DELETE FROM projects WHERE path = ?').run(folder);
+    publish();
+    return null;
+}
+export async function directories(input) {
+    const folder = path.resolve(expandHome(input.trim()));
+    const entries = await readdir(folder, { withFileTypes: true });
+    const parent = path.dirname(folder);
+    return {
+        path: folder,
+        parent: parent === folder ? null : parent,
+        directories: entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => ({
+            name: entry.name,
+            path: path.join(folder, entry.name),
+        }))
+            .sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase())),
+    };
+}
+function publish() {
+    broadcast({ type: 'projects', projects: projects() });
+}
+function toProject(row) {
+    if (typeof row.path !== 'string' ||
+        typeof row.name !== 'string' ||
+        (typeof row.logo !== 'string' && row.logo !== null))
+        throw new Error('The projects table has an unexpected row');
+    return { path: row.path, name: row.name, logo: row.logo };
+}
+function checkLogo(logo) {
+    const type = /^data:([^;,]+);base64,/.exec(logo)?.[1];
+    if (type === undefined || !LOGO_TYPES.includes(type))
+        throw new Error('Use a PNG, JPEG, GIF, WebP, SVG or ICO image');
+    if (logo.length > LOGO_LIMIT)
+        throw new Error('Use an image smaller than 384 KB');
+}
+function expandHome(input) {
+    if (input === '~')
+        return os.homedir();
+    if (input.startsWith('~/'))
+        return path.join(os.homedir(), input.slice(2));
+    return input;
+}

package/apps/server/dist/protocol.js

@@ -0,0 +1,20 @@
+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

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