offsite 0.0.3 → 0.0.4

package/apps/server/dist/config.js

@@ -1,191 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import { broadcast } from './hub.js';
-import { schemes } from './schemes.js';
-import { home, readJson, writeJson } from './storage.js';
-export const version = '0.0.0';
-const configFile = path.join(home, 'config.json');
-export const defaults = {
-    theme: schemes[0].id,
-    claudeBaseDir: path.join(os.homedir(), '.claude'),
-    composer: {
-        accountId: null,
-        model: 'haiku',
-        effort: 'low',
-        permissionMode: 'bypassPermissions',
-    },
-    terminal: {
-        shell: { macos: null, linux: null, windows: null },
-        font: {
-            family: 'FiraCode Nerd Font',
-            size: 14,
-            lineHeight: 1.35,
-            ligatures: true,
-        },
-        cursor: { style: 'bar', blink: true },
-        padding: { top: 4, right: 4, bottom: 0, left: 4 },
-        scrollback: 1000,
-        boldIsBright: true,
-        behavior: {
-            modernizeShiftEnter: true,
-            pasteBrowserImages: true,
-            showGitBranch: true,
-            captureShortcuts: true,
-            bellFlash: true,
-            bellSound: true,
-            terminalIdentity: 'offsite',
-            shellIntegration: true,
-            clickToMoveCursor: true,
-            optionAsMeta: 'off',
-            confirmCloseBusyTab: true,
-        },
-    },
-};
-const choices = {
-    theme: schemes.map((scheme) => scheme.id),
-    'composer.effort': ['low', 'medium', 'high', 'xhigh', 'max'],
-    'composer.permissionMode': [
-        'default',
-        'acceptEdits',
-        'bypassPermissions',
-        'plan',
-        'dontAsk',
-        'auto',
-    ],
-    'terminal.cursor.style': ['block', 'bar', 'underline'],
-    'terminal.behavior.terminalIdentity': ['offsite', 'ghostty', 'iterm2'],
-    'terminal.behavior.optionAsMeta': ['off', 'left', 'right', 'both'],
-};
-const nullable = [
-    'composer.accountId',
-    'composer.model',
-    'composer.effort',
-    'composer.permissionMode',
-    'terminal.shell.macos',
-    'terminal.shell.linux',
-    'terminal.shell.windows',
-];
-const integers = [
-    'terminal.scrollback',
-    'terminal.padding.top',
-    'terminal.padding.right',
-    'terminal.padding.bottom',
-    'terminal.padding.left',
-];
-export function platform() {
-    if (process.platform === 'darwin')
-        return 'macos';
-    if (process.platform === 'linux')
-        return 'linux';
-    if (process.platform === 'win32')
-        return 'windows';
-    throw new Error(`unsupported platform ${process.platform}`);
-}
-export function defaultShell() {
-    if (process.platform === 'win32')
-        return process.env.COMSPEC ?? 'cmd.exe';
-    return os.userInfo().shell ?? '/bin/sh';
-}
-export function configInfo() {
-    return {
-        config: readConfig(),
-        defaults,
-        platform: platform(),
-        version,
-        defaultShell: defaultShell(),
-    };
-}
-export function readConfig() {
-    let user;
-    try {
-        user = readJson('config.json');
-    }
-    catch (error) {
-        console.warn(`invalid ${configFile}, using the default config: ${error}`);
-        return structuredClone(defaults);
-    }
-    if (user === null)
-        return structuredClone(defaults);
-    if (!isObject(user)) {
-        console.warn(`${configFile} is not an object, using the default config`);
-        return structuredClone(defaults);
-    }
-    let config = structuredClone(defaults);
-    for (const [key, value] of Object.entries(user))
-        config = merge(config, [key], value);
-    return config;
-}
-export function saveConfig(value) {
-    const error = invalid(value, defaults, []);
-    if (error !== null)
-        throw new Error(error);
-    writeJson('config.json', value);
-    process.env.CLAUDE_CONFIG_DIR = value.claudeBaseDir;
-    broadcast({ type: 'config', config: value });
-    return value;
-}
-function merge(config, keys, user) {
-    const template = keys.reduce((value, key) => (isObject(value) ? value[key] : undefined), config);
-    if (isObject(template) && isObject(user)) {
-        let next = config;
-        for (const [key, value] of Object.entries(user))
-            next = merge(next, [...keys, key], value);
-        return next;
-    }
-    const candidate = structuredClone(config);
-    const parent = keys
-        .slice(0, -1)
-        .reduce((value, key) => value[key], candidate);
-    parent[keys[keys.length - 1]] = user;
-    const error = invalid(candidate, defaults, []);
-    if (error === null)
-        return candidate;
-    console.warn(`invalid ${keys.join('.')} in ${configFile}, using its default: ${error}`);
-    return config;
-}
-function invalid(value, template, keys) {
-    const name = keys.join('.');
-    if (isObject(template)) {
-        if (!isObject(value))
-            return `${name || 'config'} must be an object`;
-        for (const key of Object.keys(value))
-            if (!(key in template))
-                return `unknown setting ${[...keys, key].join('.')}`;
-        for (const key of Object.keys(template)) {
-            if (!(key in value))
-                return `missing setting ${[...keys, key].join('.')}`;
-            const error = invalid(value[key], template[key], [...keys, key]);
-            if (error !== null)
-                return error;
-        }
-        return null;
-    }
-    if (nullable.includes(name) && value === null)
-        return null;
-    if (name === 'claudeBaseDir')
-        return typeof value === 'string' && path.isAbsolute(value)
-            ? null
-            : 'claudeBaseDir must be an absolute path';
-    if (name in choices) {
-        if (choices[name].includes(value))
-            return null;
-        return `${name} must be one of ${choices[name].join(', ')}`;
-    }
-    if (template === null) {
-        if (typeof value === 'string')
-            return null;
-        return `${name} must be text or null`;
-    }
-    if (typeof value !== typeof template)
-        return `${name} must be a ${typeof template}`;
-    if (typeof value !== 'number')
-        return null;
-    if (!Number.isFinite(value) || value < 0)
-        return `${name} must be a number of at least 0`;
-    if (integers.includes(name) && !Number.isInteger(value))
-        return `${name} must be a whole number`;
-    return null;
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}

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 path from 'node:path';
-import { getSessionMessages, getSubagentMessages, } from '@anthropic-ai/claude-agent-sdk';
-import { readConfig } from './config.js';
-import { contextTokens, toMessage } from './content.js';
-import { runs } from './run.js';
-async function sessionEntries(sessionId) {
-    const projectsDir = path.join(readConfig().claudeBaseDir, 'projects');
-    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();
-}