session-peer 0.1.0-preview.0

package/dist/protocol.js

@@ -0,0 +1,50 @@
+import { Refusal } from './discovery.js';
+import { uuid } from './writer.js';
+export const VERSION = '0.1.0-preview.0';
+export const VERSION_LINE = `session-peer ${VERSION} (typescript)`;
+export function host(value) {
+    if (value.length > 255 || !/^(?:[A-Za-z0-9_][A-Za-z0-9_.-]*@)?[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(value))
+        throw new Refusal('invalid_ssh_host');
+    return value;
+}
+export function reply(value) {
+    if (value.length > 4096 || /[\x00-\x20\x7f]/.test(value) || /%(?![\da-f]{2})/i.test(value))
+        throw new Refusal('invalid_reply_uri');
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Refusal('invalid_reply_uri');
+    }
+    if (url.protocol !== 'session-peer:' || url.host !== 'v1' || url.pathname !== '/reply' || url.hash || url.username || url.password)
+        throw new Refusal('invalid_reply_uri');
+    const fields = new Map();
+    for (const [key, item] of url.searchParams) {
+        if (!['agent', 'session', 'transport', 'host', 'codexHome'].includes(key) || fields.has(key) || !item || /[\x00-\x1f\x7f\ufffd]/.test(item))
+            throw new Refusal('invalid_reply_uri');
+        fields.set(key, item);
+    }
+    const agent = fields.get('agent'), target = fields.get('session'), transport = fields.get('transport');
+    if (!target || !['claude', 'codex'].includes(agent ?? '') || !['local', 'ssh'].includes(transport ?? ''))
+        throw new Refusal('invalid_reply_uri');
+    if (agent === 'codex' && !uuid(target))
+        throw new Refusal('invalid_reply_uri');
+    if (agent !== 'codex' && fields.has('codexHome'))
+        throw new Refusal('invalid_reply_uri');
+    if (transport === 'local' && fields.has('host'))
+        throw new Refusal('invalid_reply_uri');
+    if (transport === 'ssh' && !fields.has('host'))
+        throw new Refusal('invalid_reply_uri');
+    return { to: agent === 'codex' ? `codex:${target}` : target,
+        ...(transport === 'ssh' ? { host: host(fields.get('host')) } : {}),
+        ...(fields.has('codexHome') ? { home: fields.get('codexHome') } : {}) };
+}
+export function envelope(text, noFrom, address) {
+    const sender = process.env.CODEX_THREAD_ID || process.env.CODEX_SESSION_ID;
+    const from = !noFrom && sender && uuid(sender) ? `From: codex:${sender}\n\n` : '';
+    if (address)
+        reply(address);
+    // No inferred identity/reverse route and no executable Reply command.
+    return from + text.replace(/^\n+|\n+$/g, '') + (address ? `\n\n---\nReply-To: ${address}` : '');
+}

package/dist/send.js

@@ -0,0 +1,88 @@
+import { createConnection } from 'node:net';
+import { canonical, claude, Refusal } from './discovery.js';
+import { executable, run, UnknownOutcome } from './process.js';
+import { resolveWriter, uuid } from './writer.js';
+export function checkMessage(text, codex = false) {
+    if (!text.trim() || text.includes('\0') || [...text].length > 1_000_000 ||
+        (codex && Buffer.byteLength(text, 'utf8') > 32768))
+        throw new Refusal('invalid_message', 2);
+}
+export async function postSocket(path, text) {
+    return new Promise((resolve, reject) => {
+        let attempted = false, finished = false;
+        const socket = createConnection(path);
+        const timer = setTimeout(() => finish(new Error('timeout')), 10000);
+        const finish = (error) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                reject(attempted ? new UnknownOutcome() : new Refusal('inbox_unreachable', 1));
+            else
+                resolve();
+        };
+        socket.on('error', error => finish(error));
+        socket.once('connect', () => {
+            attempted = true;
+            socket.end(JSON.stringify({ type: 'user', message: { role: 'user', content: text } }) + '\n', () => {
+                // Write completion is submission only, never consumption. Match Python's drain window.
+                clearTimeout(timer);
+                const drain = setTimeout(() => finish(), 2000);
+                socket.once('close', () => { clearTimeout(drain); finish(); });
+                socket.once('data', () => { clearTimeout(drain); finish(); });
+            });
+        });
+    });
+}
+export async function send(options) {
+    checkMessage(options.message, options.to.startsWith('codex:'));
+    const base = { ok: true, submitted: !options.dryRun, consumptionConfirmed: false,
+        dryRun: Boolean(options.dryRun), chars: [...options.message].length };
+    if (options.to.startsWith('codex:')) {
+        const id = options.to.slice(6).toLowerCase();
+        if (!uuid(id) || !options.home)
+            throw new Refusal('codex_uuid_and_explicit_home_required');
+        const home = canonical(options.home);
+        const binary = executable(options.codexBin ?? 'codex');
+        const evidence = await resolveWriter(home, id);
+        const result = { ...base, target: { agent: 'codex', id }, codexHome: home,
+            status: options.dryRun ? 'validated' : 'queued' };
+        if (options.dryRun)
+            return result;
+        if (await resolveWriter(home, id) !== evidence)
+            throw new Refusal('writer_evidence_changed_before_queue', 1);
+        const done = await run(binary, ['queue', '--thread', id, '--message', options.message], { env: { ...process.env, CODEX_HOME: home }, timeout: 30000 });
+        if (!done.spawned)
+            throw new Refusal('native_spawn_failed', 1);
+        if (done.interrupted || done.code !== 0)
+            throw new UnknownOutcome();
+        return result;
+    }
+    if (options.to.includes(':') && !options.to.startsWith('claude:'))
+        throw new Refusal('unsupported_agent');
+    if (options.home || options.codexBin)
+        throw new Refusal('inapplicable_option');
+    const target = options.to.replace(/^claude:/, '');
+    // ASCII name folding is explicit; Unicode names must use a PID until full casefold parity exists.
+    if (!target || /[^\x20-\x7e]/.test(target))
+        throw new Refusal('use_pid_for_unicode_name');
+    const select = () => {
+        const rows = claude(false).sessions;
+        const matches = rows.filter(r => /^\d+$/.test(target) ? r.pid === Number(target) :
+            typeof r.name === 'string' && r.name.toLowerCase() === target.toLowerCase());
+        if (matches.length !== 1)
+            throw new Refusal(matches.length ? 'ambiguous_target' : 'no_reachable_target', 2);
+        return matches[0];
+    };
+    const row = select();
+    const result = { ...base, target: { agent: 'claude', pid: row.pid, name: row.name }, status: options.dryRun ? 'validated' : 'posted' };
+    if (options.dryRun)
+        return result;
+    const rechecked = select();
+    if (row.pid !== rechecked.pid || row.socket !== rechecked.socket)
+        throw new Refusal('target_changed', 1);
+    await postSocket(String(row.socket), options.message);
+    return result;
+}

package/dist/writer.js

@@ -0,0 +1,161 @@
+import { closeSync, constants, fstatSync, lstatSync, openSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { canonical, Refusal } from './discovery.js';
+import { executable, run } from './process.js';
+const missing = (error) => ['ENOENT', 'ENOTDIR'].includes(error.code ?? '');
+export const uuid = (value) => /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/i.test(value);
+function snapshot(path) {
+    const s = lstatSync(path, { bigint: true });
+    return [s.dev, s.ino, s.size, s.mtimeNs].join(':');
+}
+export async function probeLock(path) {
+    let fd;
+    try {
+        const before = lstatSync(path);
+        if (!before.isFile() || before.isSymbolicLink())
+            return 'unknown';
+        const { flockSync } = await import('fs-ext-extra-prebuilt');
+        fd = openSync(path, constants.O_RDWR | constants.O_NOFOLLOW);
+        const after = fstatSync(fd);
+        if (before.dev !== after.dev || before.ino !== after.ino)
+            return 'unknown';
+        try {
+            flockSync(fd, 'exnb');
+        }
+        catch (error) {
+            return ['EAGAIN', 'EACCES', 'EWOULDBLOCK'].includes(error.code ?? '') ? 'held' : 'unknown';
+        }
+        flockSync(fd, 'un');
+        return 'free';
+    }
+    catch (error) {
+        return missing(error) ? 'absent' : 'unknown';
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+async function sample(path) {
+    const state = await probeLock(path);
+    if (state !== 'held')
+        return { state, fingerprint: '', owners: [], valid: true };
+    const fingerprint = snapshot(path);
+    const listed = await run(executable('lsof'), ['-nP', '-F0pcu', '--', path]);
+    const owners = [];
+    let current;
+    for (const token of listed.stdout.split(/[\0\n]/)) {
+        const value = token.slice(1).trim();
+        if (token[0] === 'p') {
+            current = { pid: Number(value) };
+            owners.push(current);
+        }
+        if (current && token[0] === 'u')
+            current.uid = Number(value);
+        if (current && token[0] === 'c')
+            current.command = value;
+    }
+    for (const owner of owners) {
+        if (!Number.isSafeInteger(owner.pid) || owner.pid <= 1)
+            continue;
+        const result = await run(executable('ps'), ['-p', String(owner.pid), '-o', 'lstart='], { env: { ...process.env, LC_ALL: 'C' } });
+        if (result.code === 0 && !result.interrupted)
+            owner.start = result.stdout.trim();
+    }
+    return { state, fingerprint, owners, valid: listed.code === 0 && !listed.interrupted };
+}
+export async function inspectWriter(home, id) {
+    const path = join(home, 'thread-writer-locks', `${id}.lock`);
+    const before = await sample(path);
+    if (before.state === 'free' || before.state === 'absent')
+        return { activity: 'inactive', identity: '' };
+    if (before.state !== 'held')
+        throw new Refusal('active_writer_unverified', 1);
+    await delay(250);
+    const after = await sample(path);
+    const owner = after.owners[0];
+    if (!before.valid || !after.valid || before.state !== after.state || before.fingerprint !== after.fingerprint ||
+        before.owners.length !== 1 || after.owners.length !== 1 || JSON.stringify(before.owners) !== JSON.stringify(after.owners) ||
+        !owner?.start || owner.uid !== process.getuid?.() || !/^codex(?:-|$)/i.test(owner.command ?? '')) {
+        throw new Refusal('active_writer_unverified', 1);
+    }
+    return { activity: 'live_writer', identity: JSON.stringify({ fingerprint: after.fingerprint, ...owner }) };
+}
+export function homes(selected) {
+    const result = new Set([canonical(selected)]);
+    const addExisting = (home) => {
+        try {
+            if (!statSync(join(home, 'state_5.sqlite')).isFile())
+                throw new Refusal('home_inventory_unreadable', 1);
+            result.add(canonical(home));
+        }
+        catch (error) {
+            if (!missing(error))
+                throw new Refusal('home_inventory_unreadable', 1);
+        }
+    };
+    addExisting(join(homedir(), '.codex'));
+    if (process.env.CODEX_HOME)
+        addExisting(process.env.CODEX_HOME);
+    if (process.platform === 'darwin') {
+        const directory = join(homedir(), 'Library/Application Support/orca/codex-accounts');
+        let entries = [];
+        try {
+            entries = readdirSync(directory).sort();
+        }
+        catch (error) {
+            if (!missing(error))
+                throw new Refusal('home_inventory_unreadable', 1);
+        }
+        for (const entry of entries)
+            addExisting(join(directory, entry, 'home'));
+    }
+    if (process.env.SESSION_PEER_CODEX_HOMES) {
+        let paths;
+        try {
+            paths = JSON.parse(process.env.SESSION_PEER_CODEX_HOMES);
+        }
+        catch {
+            throw new Refusal('invalid_home_configuration', 1);
+        }
+        if (!Array.isArray(paths) || paths.some(p => typeof p !== 'string' || (!isAbsolute(p) && !p.startsWith('~/'))))
+            throw new Refusal('invalid_home_configuration', 1);
+        for (const path of paths)
+            result.add(canonical(path));
+    }
+    return [...result].sort();
+}
+export async function resolveWriter(selected, id) {
+    const { DatabaseSync } = await import('node:sqlite');
+    const candidates = homes(selected);
+    const matches = [];
+    for (const home of candidates) {
+        let saved = false;
+        try {
+            const db = new DatabaseSync(join(home, 'state_5.sqlite'), { readOnly: true });
+            try {
+                db.exec('PRAGMA query_only=ON; PRAGMA trusted_schema=OFF; PRAGMA busy_timeout=3000');
+                saved = Boolean(db.prepare('SELECT 1 FROM threads WHERE id=? LIMIT 1').get(id));
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch {
+            throw new Refusal('home_inventory_unreadable', 1);
+        }
+        if (saved)
+            matches.push({ home, ...await inspectWriter(home, id) });
+    }
+    const live = matches.filter(c => c.activity === 'live_writer');
+    if (!matches.length)
+        throw new Refusal('thread_not_saved_in_known_homes', 2);
+    if (live.length !== 1)
+        throw new Refusal(live.length ? 'multiple_live_writers' : 'inactive_writer', 1);
+    if (live[0].home !== canonical(selected))
+        throw new Refusal('explicit_home_conflicts_with_live_writer', 1);
+    // Include inactive competitors and inventory in the pre-submit revalidation token.
+    return JSON.stringify({ candidates, matches });
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "session-peer",
+  "version": "0.1.0-preview.0",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "tag": "preview"
+  },
+  "repository": { "type": "git", "url": "git+https://github.com/abruption/session-peer-ts.git" },
+  "os": ["darwin", "linux"],
+  "description": "Python-free local and SSH client for Claude Code and Codex sessions (preview)",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": "^22.13.0 || ^24.0.0"
+  },
+  "bin": {
+    "session-peer": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.ko.md",
+    "README.ja.md",
+    "README.zh-CN.md",
+    "CONTRIBUTING.md",
+    "RELEASING.md",
+    "SECURITY.md",
+    "VALIDATION.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test test/*.test.mjs",
+    "test:package": "npm run build && node test/package-smoke.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "22.13.10",
+    "typescript": "5.9.3"
+  },
+  "dependencies": {
+    "fs-ext-extra-prebuilt": "2.2.14"
+  }
+}