offsite 0.0.0-stage → 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nazmus Sayad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,41 @@
-# Temporary Holding Version
+# offsite
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Claude Code in your browser. It uses the same sessions as the CLI, so you can start in one and resume in the other.
+
+## Usage
+
+Requires Node.js 24+ and [Claude Code](https://code.claude.com), installed and logged in.
+
+```sh
+npx offsite
+```
+
+Then open [http://127.0.0.1:47841](http://127.0.0.1:47841).
+
+| Flag     | Default      | What it sets                     |
+| -------- | ------------ | -------------------------------- |
+| `--host` | `127.0.0.1`  | Address to listen on             |
+| `--port` | `47841`      | Port to listen on                |
+| `--dir`  | `~/.offsite` | Folder for settings and accounts |
+
+> [!WARNING]
+> offsite has no login. Anyone who can reach its port can run Claude Code and open a terminal on your machine. Keep the default host.
+
+Don't use the same session in offsite and the CLI at the same time. Switching between them is fine.
+
+## 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.
+
+```sh
+CLAUDE_CONFIG_DIR=~/.claude-work npx offsite --port 47850 --dir ~/.offsite-work
+```
+
+## Development
+
+```sh
+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.

package/apps/server/dist/args.js

@@ -0,0 +1,11 @@
+import os from 'node:os';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+const { values } = parseArgs({
+    options: {
+        host: { type: 'string', default: '127.0.0.1' },
+        port: { type: 'string', default: '47841' },
+        dir: { type: 'string', default: path.join(os.homedir(), '.offsite') },
+    },
+});
+export const args = { ...values, dir: path.resolve(values.dir) };

package/apps/server/dist/claude.js

@@ -0,0 +1,196 @@
+import { randomUUID } from 'node:crypto';
+import { statSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { query, } from '@anthropic-ai/claude-agent-sdk';
+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 = '';
+export function findClaude() {
+    const name = process.platform === 'win32' ? 'claude.exe' : 'claude';
+    for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+        const candidate = path.join(dir, name);
+        if (statSync(candidate, { throwIfNoEntry: false })?.isFile()) {
+            executable = candidate;
+            return candidate;
+        }
+    }
+    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;
+    }
+    return {
+        cwd,
+        env,
+        pathToClaudeCodeExecutable: executable,
+        systemPrompt: { type: 'preset', preset: 'claude_code' },
+        hooks: {
+            PostToolUse: [
+                {
+                    matcher: 'PushNotification',
+                    hooks: [
+                        async (input) => {
+                            if (input.hook_event_name !== 'PostToolUse' ||
+                                typeof input.tool_input !== 'object' ||
+                                input.tool_input === null ||
+                                !('message' in input.tool_input) ||
+                                typeof input.tool_input.message !== 'string')
+                                throw new Error('Unexpected PushNotification hook input');
+                            broadcast({
+                                type: 'notification',
+                                sessionId: input.session_id,
+                                message: input.tool_input.message,
+                            });
+                            return {
+                                hookSpecificOutput: {
+                                    hookEventName: 'PostToolUse',
+                                    updatedToolOutput: {
+                                        message: input.tool_input.message,
+                                        localSent: true,
+                                        disabledReason: 'no_transport',
+                                    },
+                                },
+                            };
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+}
+export async function capabilities(accountId, cwd) {
+    const result = await initialization(accountId, cwd);
+    return {
+        models: result.models.map((model) => ({
+            value: model.value,
+            name: model.displayName,
+            description: model.description,
+            efforts: model.supportedEffortLevels ?? [],
+        })),
+        commands: result.commands.map((command) => ({
+            name: command.name,
+            description: command.description,
+            hint: command.argumentHint,
+        })),
+    };
+}
+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) => {
+        try {
+            const info = (await initialization(account.id, os.homedir())).account;
+            return {
+                ...account,
+                email: info.email ?? null,
+                plan: info.subscriptionType ?? null,
+                error: null,
+                limits: accountLimits(account.id),
+            };
+        }
+        catch (error) {
+            return {
+                ...account,
+                email: null,
+                plan: null,
+                error: error instanceof Error ? error.message : String(error),
+                limits: accountLimits(account.id),
+            };
+        }
+    }));
+}
+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`');
+    saveAccounts([
+        ...storedAccounts(),
+        { id: randomUUID(), name: name.trim(), token: token.trim() },
+    ]);
+}
+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);
+}
+export function recordLimit(accountId, info) {
+    const current = limits.get(accountId) ?? new Map();
+    const windows = info.unifiedWindows;
+    if (isRecord(windows))
+        for (const [name, value] of Object.entries(windows))
+            if (isRecord(value))
+                current.set(name, {
+                    window: name,
+                    utilization: typeof value.utilization === 'number' ? value.utilization : null,
+                    resetsAt: typeof value.resetsAt === 'number' ? value.resetsAt : null,
+                    rejected: current.get(name)?.rejected ?? false,
+                });
+    if (info.rateLimitType !== undefined) {
+        const existing = current.get(info.rateLimitType);
+        current.set(info.rateLimitType, {
+            window: info.rateLimitType,
+            utilization: info.utilization ?? existing?.utilization ?? null,
+            resetsAt: info.resetsAt ?? existing?.resetsAt ?? null,
+            rejected: info.status === 'rejected',
+        });
+    }
+    limits.set(accountId, current);
+    return accountLimits(accountId);
+}
+function accountLimits(accountId) {
+    return [...(limits.get(accountId)?.values() ?? [])];
+}
+function initialization(accountId, cwd) {
+    const key = `${accountId}\n${cwd}`;
+    const existing = probes.get(key);
+    if (existing !== undefined)
+        return existing;
+    const probe = runProbe(accountId, cwd);
+    probes.set(key, probe);
+    probe.catch(() => probes.delete(key));
+    return probe;
+}
+async function runProbe(accountId, cwd) {
+    const closed = Promise.withResolvers();
+    const probe = query({
+        prompt: idle(closed.promise),
+        options: claudeOptions(accountId, cwd),
+    });
+    try {
+        return await probe.initializationResult();
+    }
+    finally {
+        closed.resolve();
+        probe.close();
+    }
+}
+async function* idle(until) {
+    await until;
+    yield* [];
+}
+function storedAccounts() {
+    return readJson('accounts.json') ?? [];
+}
+function saveAccounts(items) {
+    writeJson('accounts.json', items);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/apps/server/dist/config.js

@@ -0,0 +1,184 @@
+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,
+    composer: {
+        accountId: 'default',
+        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.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);
+    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 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

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

@@ -0,0 +1,12 @@
+import { broadcast } from './hub.js';
+import { readJson, writeJson } from './storage.js';
+export function folders() {
+    return readJson('folders.json') ?? [];
+}
+export function saveFolders(next) {
+    if (!Array.isArray(next) || !next.every((item) => typeof item === 'string'))
+        throw new Error('folders must be a list of paths');
+    writeJson('folders.json', next);
+    broadcast({ type: 'folders', folders: next });
+    return next;
+}