offsite 0.0.2 → 0.0.4

package/apps/server/dist/content.js

@@ -1,172 +0,0 @@
-export function toMessage(type, item, time) {
-    return {
-        type,
-        uuid: item.uuid,
-        time,
-        content: isRecord(item.message) ? toBlocks(item.message.content) : [],
-        parent: item.parent_tool_use_id,
-    };
-}
-export function contextTokens(message) {
-    if (!isRecord(message) || !isRecord(message.usage))
-        return null;
-    const usage = message.usage;
-    return [
-        usage.input_tokens,
-        usage.cache_creation_input_tokens,
-        usage.cache_read_input_tokens,
-        usage.output_tokens,
-    ].reduce((total, value) => total + (typeof value === 'number' ? value : 0), 0);
-}
-export function toContext(usage) {
-    const messages = usage.messageBreakdown;
-    const sections = [
-        {
-            title: 'Messages',
-            items: messages === undefined
-                ? []
-                : [
-                    { name: 'User messages', tokens: messages.userMessageTokens },
-                    {
-                        name: 'Assistant messages',
-                        tokens: messages.assistantMessageTokens,
-                    },
-                    { name: 'Tool calls', tokens: messages.toolCallTokens },
-                    { name: 'Tool results', tokens: messages.toolResultTokens },
-                    { name: 'Attachments', tokens: messages.attachmentTokens },
-                ],
-        },
-        {
-            title: 'Tools used',
-            items: (messages?.toolCallsByType ?? []).map((tool) => ({
-                name: tool.name,
-                tokens: tool.callTokens + tool.resultTokens,
-            })),
-        },
-        {
-            title: 'Memory files',
-            items: usage.memoryFiles.map((file) => ({
-                name: file.path,
-                tokens: file.tokens,
-            })),
-        },
-        {
-            title: 'MCP tools',
-            items: usage.mcpTools.map((tool) => ({
-                name: `${tool.serverName} · ${tool.name}`,
-                tokens: tool.tokens,
-            })),
-        },
-        {
-            title: 'Agents',
-            items: usage.agents.map((agent) => ({
-                name: agent.agentType,
-                tokens: agent.tokens,
-            })),
-        },
-        {
-            title: 'Skills',
-            items: (usage.skills?.skillFrontmatter ?? []).map((skill) => ({
-                name: skill.name,
-                tokens: skill.tokens,
-            })),
-        },
-        {
-            title: 'Last response',
-            items: usage.apiUsage === null
-                ? []
-                : [
-                    { name: 'Input', tokens: usage.apiUsage.input_tokens },
-                    {
-                        name: 'Cache read',
-                        tokens: usage.apiUsage.cache_read_input_tokens,
-                    },
-                    {
-                        name: 'Cache write',
-                        tokens: usage.apiUsage.cache_creation_input_tokens,
-                    },
-                    { name: 'Output', tokens: usage.apiUsage.output_tokens },
-                ],
-        },
-    ];
-    return {
-        tokens: usage.totalTokens,
-        window: usage.maxTokens,
-        model: usage.model,
-        categories: usage.categories.flatMap((category) => category.kind === 'deferred'
-            ? []
-            : [
-                {
-                    name: category.name,
-                    tokens: category.tokens,
-                    kind: category.kind,
-                },
-            ]),
-        sections: sections
-            .map((section) => ({
-            title: section.title,
-            items: section.items.filter((item) => item.tokens > 0),
-        }))
-            .filter((section) => section.items.length > 0),
-    };
-}
-function toBlocks(content) {
-    if (typeof content === 'string')
-        return [{ type: 'text', text: content }];
-    if (!Array.isArray(content))
-        return [];
-    return content.flatMap((block) => {
-        if (!isRecord(block))
-            return [];
-        switch (block.type) {
-            case 'text':
-                return typeof block.text === 'string' &&
-                    !block.text.startsWith('<system-reminder>') &&
-                    !block.text.startsWith('<local-command-caveat>')
-                    ? [{ type: 'text', text: block.text }]
-                    : [];
-            case 'thinking':
-                return typeof block.thinking === 'string' && block.thinking !== ''
-                    ? [{ type: 'thinking', thinking: block.thinking }]
-                    : [];
-            case 'image': {
-                const source = block.source;
-                return isRecord(source) &&
-                    source.type === 'base64' &&
-                    typeof source.media_type === 'string' &&
-                    typeof source.data === 'string'
-                    ? [{ type: 'image', mediaType: source.media_type, data: source.data }]
-                    : [];
-            }
-            case 'tool_use':
-                return typeof block.id === 'string' &&
-                    typeof block.name === 'string' &&
-                    isRecord(block.input)
-                    ? [
-                        {
-                            type: 'tool_use',
-                            id: block.id,
-                            name: block.name,
-                            input: block.input,
-                        },
-                    ]
-                    : [];
-            case 'tool_result':
-                return typeof block.tool_use_id === 'string'
-                    ? [
-                        {
-                            type: 'tool_result',
-                            toolUseId: block.tool_use_id,
-                            content: toBlocks(block.content),
-                            isError: block.is_error === true,
-                        },
-                    ]
-                    : [];
-            default:
-                return [];
-        }
-    });
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}

package/apps/server/dist/db.js

@@ -1,13 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import path from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { home } from './storage.js';
-mkdirSync(home, { recursive: true });
-export const db = new DatabaseSync(path.join(home, 'offsite.db'));
-db.exec(`
-  CREATE TABLE IF NOT EXISTS projects (
-    path TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    logo TEXT
-  )
-`);

package/apps/server/dist/files.js

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

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

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

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

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

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