offsite 0.0.1 → 0.0.3

package/README.md

@@ -25,10 +25,10 @@ Don't use the same session in offsite and the CLI at the same time. Switching be
 
 ## Separate instances
 
-Give each instance its own port and `--dir`. Set `CLAUDE_CONFIG_DIR` too if it should have its own Claude Code sessions and login.
+Give each instance its own port and `--dir`.
 
 ```sh
-CLAUDE_CONFIG_DIR=~/.claude-work npx offsite --port 47850 --dir ~/.offsite-work
+npx offsite --port 47850 --dir ~/.offsite-work
 ```
 
 ## Development
@@ -38,4 +38,4 @@ pnpm install
 pnpm dev
 ```
 
-The web app runs at [http://localhost:5173](http://localhost:5173). The server runs on port 47842 and keeps its data in `~/.offsite-dev` and `~/.claude-test`, apart from your main instance.
+The web app runs at [http://localhost:5173](http://localhost:5173). The server runs on port 47842 and keeps its data in `~/.offsite-dev`, apart from your main instance.

package/apps/server/dist/claude.js

@@ -1,11 +1,12 @@
 import { randomUUID } from 'node:crypto';
-import { statSync } from 'node:fs';
+import { realpathSync, statSync } from 'node:fs';
+import { mkdir, rm, symlink } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
+import { readConfig } from './config.js';
 import { broadcast } from './hub.js';
 import { readJson, writeJson } from './storage.js';
-export const DEFAULT_ACCOUNT = 'default';
 const probes = new Map();
 const limits = new Map();
 let executable = '';
@@ -21,19 +22,18 @@ export function findClaude() {
     return null;
 }
 export function claudeOptions(accountId, cwd) {
-    const env = {
-        ...process.env,
-        CLAUDE_CODE_ENTRYPOINT: 'offsite',
-    };
-    if (accountId !== DEFAULT_ACCOUNT) {
-        const account = storedAccounts().find((item) => item.id === accountId);
-        if (account === undefined)
-            throw new Error('That account was removed');
-        env.CLAUDE_CODE_OAUTH_TOKEN = account.token;
-    }
+    if (accountId === null)
+        throw new Error('Add a Claude account in Settings → Accounts');
+    const account = storedAccounts().find((item) => item.id === accountId);
+    if (account === undefined)
+        throw new Error('That account was removed');
     return {
         cwd,
-        env,
+        env: {
+            ...process.env,
+            CLAUDE_CODE_ENTRYPOINT: 'offsite',
+            CLAUDE_CONFIG_DIR: account.configDir,
+        },
         pathToClaudeCodeExecutable: executable,
         systemPrompt: { type: 'preset', preset: 'claude_code' },
         hooks: {
@@ -87,11 +87,7 @@ export async function capabilities(accountId, cwd) {
     };
 }
 export async function accounts() {
-    const all = [
-        { id: DEFAULT_ACCOUNT, name: 'Claude login' },
-        ...storedAccounts().map(({ id, name }) => ({ id, name })),
-    ];
-    return Promise.all(all.map(async (account) => {
+    return Promise.all(storedAccounts().map(async (account) => {
         try {
             const info = (await initialization(account.id, os.homedir())).account;
             return {
@@ -100,6 +96,7 @@ export async function accounts() {
                 plan: info.subscriptionType ?? null,
                 error: null,
                 limits: accountLimits(account.id),
+                linked: linked(account.configDir),
             };
         }
         catch (error) {
@@ -109,26 +106,45 @@ export async function accounts() {
                 plan: null,
                 error: error instanceof Error ? error.message : String(error),
                 limits: accountLimits(account.id),
+                linked: linked(account.configDir),
             };
         }
     }));
 }
-export function addAccount(name, token) {
-    if (name.trim() === '')
-        throw new Error('Give the account a name');
-    if (!token.trim().startsWith('sk-ant-'))
-        throw new Error('Paste the token printed by `claude setup-token`');
+export async function publishAccounts() {
+    try {
+        broadcast({ type: 'accounts', accounts: await accounts() });
+    }
+    catch (error) {
+        console.warn(`could not list accounts: ${error}`);
+    }
+}
+export function addAccount(name, configDir) {
     saveAccounts([
         ...storedAccounts(),
-        { id: randomUUID(), name: name.trim(), token: token.trim() },
+        { id: randomUUID(), ...validAccount(name, configDir) },
     ]);
 }
+export function updateAccount(id, name, configDir) {
+    const account = validAccount(name, configDir);
+    saveAccounts(storedAccounts().map((item) => (item.id === id ? { id, ...account } : item)));
+    forget(id);
+}
 export function removeAccount(id) {
     saveAccounts(storedAccounts().filter((item) => item.id !== id));
-    for (const key of probes.keys())
-        if (key.startsWith(`${id}\n`))
-            probes.delete(key);
-    limits.delete(id);
+    forget(id);
+}
+export async function linkAccount(id) {
+    const account = storedAccounts().find((item) => item.id === id);
+    if (account === undefined)
+        throw new Error('That account was removed');
+    if (linked(account.configDir))
+        throw new Error('This account is already linked');
+    const base = path.join(readConfig().claudeBaseDir, 'projects');
+    const link = path.join(account.configDir, 'projects');
+    await mkdir(base, { recursive: true });
+    await rm(link, { recursive: true, force: true });
+    await symlink(base, link, 'junction');
 }
 export function recordLimit(accountId, info) {
     const current = limits.get(accountId) ?? new Map();
@@ -154,6 +170,39 @@ export function recordLimit(accountId, info) {
     limits.set(accountId, current);
     return accountLimits(accountId);
 }
+function validAccount(name, configDir) {
+    if (name.trim() === '')
+        throw new Error('Give the account a name');
+    const dir = configDir.trim();
+    if (dir === '~' || dir.startsWith('~/'))
+        return {
+            name: name.trim(),
+            configDir: path.join(os.homedir(), dir.slice(1)),
+        };
+    if (path.isAbsolute(dir))
+        return { name: name.trim(), configDir: dir };
+    throw new Error('Use an absolute config directory or one starting with ~/');
+}
+function linked(configDir) {
+    const base = readConfig().claudeBaseDir;
+    try {
+        if (realpathSync(configDir) === realpathSync(base))
+            return true;
+        return (realpathSync(path.join(configDir, 'projects')) ===
+            realpathSync(path.join(base, 'projects')));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function forget(accountId) {
+    for (const key of probes.keys())
+        if (key.startsWith(`${accountId}\n`))
+            probes.delete(key);
+    limits.delete(accountId);
+}
 function accountLimits(accountId) {
     return [...(limits.get(accountId)?.values() ?? [])];
 }

package/apps/server/dist/config.js

@@ -7,8 +7,9 @@ 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: 'default',
+        accountId: null,
         model: 'haiku',
         effort: 'low',
         permissionMode: 'bypassPermissions',
@@ -56,6 +57,7 @@ const choices = {
     'terminal.behavior.optionAsMeta': ['off', 'left', 'right', 'both'],
 };
 const nullable = [
+    'composer.accountId',
     'composer.model',
     'composer.effort',
     'composer.permissionMode',
@@ -118,6 +120,7 @@ export function saveConfig(value) {
     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;
 }
@@ -159,6 +162,10 @@ function invalid(value, template, keys) {
     }
     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;

package/apps/server/dist/db.js

@@ -0,0 +1,13 @@
+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/history.js

@@ -1,12 +1,11 @@
 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 { readConfig } from './config.js';
 import { contextTokens, toMessage } from './content.js';
 import { runs } from './run.js';
-const projectsDir = path.join(process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), '.claude'), 'projects');
-async function messageTimes(sessionId) {
-    const times = new Map();
+async function sessionEntries(sessionId) {
+    const projectsDir = path.join(readConfig().claudeBaseDir, 'projects');
     for (const dir of await readdir(projectsDir)) {
         let text;
         try {
@@ -17,17 +16,31 @@ async function messageTimes(sessionId) {
                 continue;
             throw error;
         }
-        for (const line of text.split('\n')) {
+        return text.split('\n').flatMap((line) => {
             const entry = parseLine(line);
-            if (entry !== null &&
-                typeof entry.uuid === 'string' &&
-                typeof entry.timestamp === 'string')
-                times.set(entry.uuid, Date.parse(entry.timestamp));
-        }
-        return times;
+            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);
@@ -36,19 +49,22 @@ function parseLine(line) {
         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, times] = await Promise.all([
+    const [disk, entries] = await Promise.all([
         getSessionMessages(sessionId, { dir: cwd }),
-        messageTimes(sessionId),
+        sessionEntries(sessionId),
     ]);
     const resumeAt = run?.resumeAt ?? null;
     const kept = resumeAt === null
         ? disk
         : disk.slice(0, disk.findIndex((item) => item.uuid === resumeAt) + 1);
-    const messages = kept.flatMap((item) => item.type === 'system' || item.parent_tool_use_id !== null
-        ? []
-        : [toMessage(item.type, item, times.get(item.uuid) ?? null)]);
+    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);
@@ -67,8 +83,26 @@ export async function history(sessionId, cwd) {
             (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' &&

package/apps/server/dist/main.js

@@ -4,8 +4,10 @@ import path from 'node:path';
 import { WebSocketServer } from 'ws';
 import { args } from './args.js';
 import { findClaude } from './claude.js';
+import { readConfig } from './config.js';
 import { startPush } from './push.js';
 import { stopAll } from './runs.js';
+import { watchSessions } from './sessions.js';
 import { connectClient } from './socket.js';
 const contentTypes = {
     '.html': 'text/html; charset=utf-8',
@@ -23,6 +25,8 @@ if (!Number.isInteger(port) || port < 1 || port > 65535) {
     console.error(`invalid port ${args.port}`);
     process.exit(1);
 }
+process.env.CLAUDE_CONFIG_DIR = readConfig().claudeBaseDir;
+watchSessions();
 if (findClaude() === null) {
     console.error('could not find claude on PATH; install Claude Code first');
     process.exit(1);
@@ -44,10 +48,12 @@ server.listen(port, args.host, () => {
     startPush(`${args.host}:${port}`);
     console.log(`offsite is running at http://${args.host}:${port}`);
 });
-process.on('SIGINT', () => {
+process.on('SIGINT', stop);
+process.on('SIGTERM', stop);
+function stop() {
     stopAll();
     process.exit(0);
-});
+}
 function serveFile(pathname, response) {
     const requested = path.join(publicDir, path.normalize(pathname));
     const file = requested.startsWith(publicDir + path.sep) &&

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/run.js

@@ -235,13 +235,17 @@ export class Run {
                         text: message.event.delta.text,
                     });
                 return;
-            case 'rate_limit_event':
+            case 'rate_limit_event': {
+                const accountId = this.settings.accountId;
+                if (accountId === null)
+                    throw new Error('Rate limit event for a run without an account');
                 broadcast({
                     type: 'limits',
-                    accountId: this.settings.accountId,
-                    limits: recordLimit(this.settings.accountId, message.rate_limit_info),
+                    accountId,
+                    limits: recordLimit(accountId, message.rate_limit_info),
                 });
                 return;
+            }
             case 'result':
                 if (message.subtype !== 'success')
                     this.add(notice(message.errors.join('\n') || message.subtype));

package/apps/server/dist/sessions.js

@@ -1,22 +1,57 @@
+import { watch } from 'node:fs';
+import path from 'node:path';
 import { deleteSession, forkSession, getSessionMessages, listSessions, renameSession, } from '@anthropic-ai/claude-agent-sdk';
+import { readConfig } from './config.js';
+import { broadcast } from './hub.js';
+import { projects } from './projects.js';
 import { runs } from './run.js';
 import { readJson, writeJson } from './storage.js';
+let watcher = null;
+let timer;
 export async function sessions() {
-    const items = await listSessions({ includeProgrammatic: false });
     const marks = readMarks();
-    return items.flatMap((item) => item.cwd === undefined
-        ? []
-        : [
-            {
-                id: item.sessionId,
-                title: item.summary,
-                cwd: item.cwd,
-                branch: item.gitBranch ?? null,
-                updatedAt: item.lastModified,
-                pinned: marks.pinned.includes(item.sessionId),
-                archived: marks.archived.includes(item.sessionId),
-            },
-        ]);
+    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 publishSessions() {
+    try {
+        broadcast({ type: 'sessions', sessions: await sessions() });
+    }
+    catch (error) {
+        console.warn(`could not list threads: ${error}`);
+    }
+}
+export function watchSessions() {
+    watcher?.close();
+    watcher = null;
+    const dir = path.join(readConfig().claudeBaseDir, 'projects');
+    try {
+        watcher = watch(dir, { recursive: true }, () => {
+            timer ??= setTimeout(() => {
+                timer = undefined;
+                void publishSessions();
+            }, 1000);
+        });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        console.warn(`${dir} does not exist; threads changed outside offsite will not show`);
+        return;
+    }
+    watcher.on('error', (error) => console.warn(`stopped watching ${dir}: ${error}`));
 }
 export async function updateSession(id, patch) {
     if (patch.title !== undefined)