moqi-tui 0.2.0

package/bin/moqi.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * The `moqi` launcher: install (or refresh) the `tui` profile, then
+ * hand off to `dsh --profile tui`.
+ *
+ * Works identically from a git checkout and a global npm install — the
+ * package root is resolved from this file's own location, and the profile's
+ * `link:` dependency points at whichever copy is running.
+ */
+import { execFileSync } from 'node:child_process'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const root = resolve(here, '..')
+
+const args = process.argv.slice(2)
+const command = args[0] === 'install' ? 'install' : 'run'
+
+try {
+  // The installer is plain Node with no build step, so it runs from source.
+  execFileSync(process.execPath, [resolve(root, 'scripts', 'install-profile.mjs'), 'tui'], {
+    stdio: 'inherit',
+  })
+} catch {
+  process.exit(1)
+}
+
+if (command === 'install') {
+  console.log('moqi: profile installed — start it with `dsh --profile tui`')
+  process.exit(0)
+}
+
+// Hand the terminal over to dsh itself; the exit code is the app's.
+try {
+  const dsh = process.env['DSH_BIN'] ?? 'dsh'
+  execFileSync(dsh, ['--profile', 'tui', ...args], { stdio: 'inherit' })
+} catch (error) {
+  process.exitCode = typeof error?.status === 'number' ? error.status : 1
+}

package/cordis.patch.yml

@@ -0,0 +1,41 @@
+# The moqi bundle patch: an interactive terminal app over dsh-base.
+#
+# It mounts no Host, HTTP server, or browser plugin — the terminal is the only
+# surface. A startup provider parses this app's own flags out of the shared
+# cmdline snapshot, and the app row consumes them lazily the way the shipped
+# headless bundle does.
+
+- id: system-prompt
+  config:
+    personaSuffix: Your working directory is {{cwd}}.
+    personaPrefix: >-
+      You are a coding agent powered by the {{model}} model.
+
+- id: tools
+  config:
+    mode: !!js process.env.DSH_TOOLS_MODE
+
+- insert:
+    - id: tui-startup
+      name: 'moqi-tui/startup'
+
+    - id: tui-app
+      name: 'moqi-tui'
+      inject: [tuiStartup]
+      config:
+        resumeSessionId: !!js ctx.tuiStartup.resumeSessionId
+        model: !!js ctx.tuiStartup.model
+        thinking: !!js ctx.tuiStartup.thinking
+        contextLimit: !!js ctx.tuiStartup.contextLimit
+        mouse: !!js ctx.tuiStartup.mouse
+        bell: !!js ctx.tuiStartup.bell
+        peers: !!js ctx.tuiStartup.peers
+        restore: !!js ctx.tuiStartup.restore
+        voiceModel: !!js ctx.tuiStartup.voiceModel
+        voiceBin: !!js ctx.tuiStartup.voiceBin
+        dispatchProfile: !!js ctx.tuiStartup.dispatchProfile
+
+# The terminal owns the screen; a hot reload repainting underneath it would
+# corrupt the alternate buffer.
+- id: hmr
+  disabled: true

package/lib/cross-find.js

@@ -0,0 +1,217 @@
+/**
+ * Cross-session search: `/find --sessions`.
+ *
+ * Stored sessions live under `$DSH_HOME/sessions/<projectKey>/<sessionId>/` as
+ * either a plain `.jsonl` log or a zstd-compressed one. This module walks them,
+ * reads whichever form it finds, and returns the matching lines with enough
+ * context to recognize the conversation — no index, no cache, and nothing
+ * written, so it can never corrupt a log another process is appending to.
+ *
+ * The zstd decoder is feature-detected: on a Node without it, compressed logs
+ * are skipped and reported as such rather than silently ignored.
+ * @module
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { zstdDecompressSync } from 'node:zlib';
+export const DEFAULT_LIMITS = {
+    maxSessions: 400,
+    maxHits: 80,
+    maxBytes: 4_000_000,
+};
+/** Whether this build of Node can decompress a zstd log. */
+export function zstdAvailable() {
+    return typeof zstdDecompressSync === 'function';
+}
+/** Extract printable message text from one JSONL record, or `''`. */
+function textOfRecord(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { text: '' };
+    }
+    const record = parsed;
+    const type = String(record.type ?? '');
+    const role = type === 'user/message' ? 'user' : type === 'assistant/message' ? 'assistant' : undefined;
+    if (role === undefined)
+        return { text: '' };
+    const blocks = record.data?.message?.content;
+    if (!Array.isArray(blocks))
+        return { text: '' };
+    const text = blocks
+        .filter((block) => {
+        const candidate = block;
+        return candidate.type === 'text' && typeof candidate.text === 'string';
+    })
+        .map((block) => block.text)
+        .join(' ');
+    return { text, ...(role === undefined ? {} : { role }) };
+}
+/**
+ * Parse a whole JSONL session body into its visible messages.
+ *
+ * Shared by cross-session search and the fleet preview, so both read a log the
+ * same way — including a foreign device's log, which may be an older format
+ * whose unknown records are simply skipped.
+ */
+export function parseLogMessages(body) {
+    const messages = [];
+    for (const raw of body.split('\n')) {
+        if (!raw.includes('"'))
+            continue;
+        const { text, role } = textOfRecord(raw);
+        if (text === '' || role === undefined)
+            continue;
+        messages.push({ role, text });
+    }
+    return messages;
+}
+/** Whether a buffer carries the zstd frame magic. */
+export function isZstdFrame(bytes) {
+    return bytes.length >= 4 && bytes[0] === 0x28 && bytes[1] === 0xb5 && bytes[2] === 0x2f && bytes[3] === 0xfd;
+}
+/** Decode raw log bytes, whichever form they arrived in. */
+export function decodeLogBytes(bytes) {
+    if (!isZstdFrame(bytes))
+        return Buffer.from(bytes).toString('utf8');
+    if (!zstdAvailable())
+        return undefined;
+    try {
+        return zstdDecompressSync(bytes).toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read one log file, decompressing when it is zstd, bounded by `maxBytes`. */
+function readLog(path, maxBytes) {
+    try {
+        const raw = readFileSync(path);
+        if (path.endsWith('.zstd')) {
+            if (!zstdAvailable())
+                return undefined;
+            // A compressed frame cannot be decoded from a prefix, so the whole file
+            // is decoded — but a log beyond the byte ceiling is skipped rather than
+            // held in memory twice.
+            if (raw.byteLength > maxBytes)
+                return undefined;
+            try {
+                return zstdDecompressSync(raw).toString('utf8');
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const slice = raw.byteLength > maxBytes ? raw.subarray(0, maxBytes) : raw;
+        return slice.toString('utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Session directories under the store root, most recently modified first. */
+function sessionDirs(root) {
+    const found = [];
+    let projects;
+    try {
+        projects = readdirSync(root);
+    }
+    catch {
+        return found;
+    }
+    for (const project of projects) {
+        const projectDir = join(root, project);
+        let entries;
+        try {
+            entries = readdirSync(projectDir);
+        }
+        catch {
+            continue;
+        }
+        for (const id of entries) {
+            if (!id.startsWith('session-'))
+                continue;
+            const dir = join(projectDir, id);
+            try {
+                if (!statSync(dir).isDirectory())
+                    continue;
+                found.push({ project, dir, id, mtime: statSync(dir).mtimeMs });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    found.sort((a, b) => b.mtime - a.mtime);
+    return found;
+}
+/** The log file inside a session directory, whichever format it is. */
+function logFile(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return undefined;
+    }
+    const zstd = entries.find((name) => name.endsWith('.jsonl.zstd'));
+    if (zstd !== undefined)
+        return join(dir, zstd);
+    const plain = entries.find((name) => name.endsWith('.jsonl'));
+    return plain === undefined ? undefined : join(dir, plain);
+}
+/**
+ * Search every stored session for a case-insensitive substring.
+ *
+ * @returns matching lines in session order (newest session first), capped by
+ *   the limits. Skipped compressed logs on a Node without zstd mean fewer
+ *   results, never wrong ones.
+ */
+export function searchSessions(root, query, limits = DEFAULT_LIMITS) {
+    const needle = query.trim().toLowerCase();
+    if (needle === '')
+        return { hits: [], scanned: 0, skippedCompressed: 0 };
+    const hits = [];
+    let scanned = 0;
+    let skippedCompressed = 0;
+    for (const candidate of sessionDirs(root)) {
+        if (scanned >= limits.maxSessions || hits.length >= limits.maxHits)
+            break;
+        const path = logFile(candidate.dir);
+        if (path === undefined)
+            continue;
+        if (path.endsWith('.zstd') && !zstdAvailable()) {
+            skippedCompressed += 1;
+            continue;
+        }
+        const body = readLog(path, limits.maxBytes);
+        if (body === undefined)
+            continue;
+        scanned += 1;
+        for (const raw of body.split('\n')) {
+            if (hits.length >= limits.maxHits)
+                break;
+            if (!raw.includes('"'))
+                continue;
+            const { text, role } = textOfRecord(raw);
+            if (text === '')
+                continue;
+            const context = text.replace(/\s+/g, ' ').trim();
+            const index = context.toLowerCase().indexOf(needle);
+            if (index === -1)
+                continue;
+            const at = Math.max(index - 30, 0);
+            const snippet = context.slice(at, at + 140);
+            hits.push({
+                sessionId: candidate.id,
+                project: candidate.project.replace(/^--|--$/g, ''),
+                line: at > 0 ? `…${snippet}` : snippet,
+                ...(role === undefined ? {} : { role }),
+                path,
+            });
+        }
+    }
+    return { hits, scanned, skippedCompressed };
+}

package/lib/file-index.js

@@ -0,0 +1,121 @@
+/**
+ * A bounded, cached walk of the workspace for `@` file completion.
+ *
+ * The listing is refreshable rather than watched: completion is an
+ * interactive nicety, so a few seconds of staleness after a checkout or a
+ * build costs nothing, while a filesystem watcher would cost a handle and a
+ * failure mode.
+ * @module
+ */
+import { readdirSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { SKIP_DIRECTORIES } from "./tui/atfile.js";
+/** Hard ceiling on walked entries, so a giant monorepo cannot stall a keystroke. */
+const MAX_ENTRIES = 4000;
+/** How deep the walk descends. */
+const MAX_DEPTH = 8;
+/** Milliseconds a listing stays fresh. */
+const FRESH_MS = 5000;
+/** Files ending here are never offered; nothing good comes of picking one. */
+const SKIP_SUFFIXES = ['.lock', '.min.js', '.map'];
+/** One workspace's file list, recomputed lazily on demand. */
+export class FileIndex {
+    root;
+    entries = [];
+    readAt = 0;
+    reading = false;
+    constructor(root) {
+        this.root = root;
+    }
+    /** Every workspace-relative file path, oldest acceptable snapshot or fresh. */
+    list() {
+        if (Date.now() - this.readAt > FRESH_MS && !this.reading)
+            this.refresh();
+        return this.entries;
+    }
+    /** Synchronously rebuild the listing. Errors leave the previous snapshot. */
+    refresh() {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            const found = [];
+            this.walk(this.root, 0, found);
+            this.entries = found;
+            this.readAt = Date.now();
+        }
+        catch {
+            // An unreadable workspace keeps the last good listing (or empty).
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    walk(directory, depth, found) {
+        if (depth >= MAX_DEPTH || found.length >= MAX_ENTRIES)
+            return;
+        let names;
+        try {
+            names = readdirSync(directory);
+        }
+        catch {
+            return;
+        }
+        for (const name of names) {
+            if (found.length >= MAX_ENTRIES)
+                return;
+            if (name.startsWith('.') && name !== '.github')
+                continue;
+            const full = join(directory, name);
+            let stats;
+            try {
+                stats = statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stats.isDirectory()) {
+                if (SKIP_DIRECTORIES.has(name))
+                    continue;
+                this.walk(full, depth + 1, found);
+            }
+            else if (stats.isFile()) {
+                if (SKIP_SUFFIXES.some((suffix) => name.endsWith(suffix)))
+                    continue;
+                const rel = relative(this.root, full);
+                found.push(sep === '/' ? rel : rel.replaceAll(sep, '/'));
+            }
+        }
+    }
+    /**
+     * List one directory for a path-shaped query, relative to the workspace
+     * root. `.` and `..` are offered alongside the entries so navigation works
+     * the way a shell expects.
+     */
+    listDir(relativePath) {
+        const base = relativePath === '' ? this.root : join(this.root, relativePath);
+        let names;
+        try {
+            names = readdirSync(base);
+        }
+        catch {
+            return { files: [] };
+        }
+        const prefix = relativePath === '' ? '' : `${relativePath.replaceAll(sep, '/')}/`;
+        const files = [];
+        for (const name of names.slice(0, MAX_ENTRIES)) {
+            if (name.startsWith('.'))
+                continue;
+            let stats;
+            try {
+                stats = statSync(join(base, name));
+            }
+            catch {
+                continue;
+            }
+            files.push({ path: `${prefix}${name}`, directory: stats.isDirectory() });
+        }
+        files.sort((a, b) => Number(b.directory) - Number(a.directory) || a.path.localeCompare(b.path));
+        return { files };
+    }
+}

package/lib/fleet-sources.js

@@ -0,0 +1,114 @@
+/**
+ * Collecting presence records from this device and its peers.
+ *
+ * The transport is SSH, for one reason: it is the only channel in this setup
+ * that is already authenticated, already encrypted, and already working. The
+ * Harness's own web server offers no TLS, no authentication and no origin
+ * policy, and binding it off loopback would publish every route on the
+ * network — so the overview never does that.
+ *
+ * Every remote read is one short, non-interactive command. Nothing is
+ * installed on the peer beyond dsh itself, and nothing listens anywhere.
+ * @module
+ */
+import { execFile } from 'node:child_process';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readPresenceDir } from "./presence.js";
+import { isPresenceRecord, } from "./tui/fleet.js";
+/** How long a peer may take before it is reported unreachable. */
+const SSH_TIMEOUT_MS = 6000;
+/** Resolve this device's Harness home the way the Harness itself does. */
+export function localDshHome(env = process.env) {
+    const configured = env['DSH_HOME'];
+    if (configured !== undefined && configured.trim() !== '')
+        return configured;
+    return join(homedir(), '.dsh');
+}
+/** Read this device's records. */
+export function collectLocal(dshHome = localDshHome()) {
+    return {
+        host: 'local',
+        local: true,
+        records: readPresenceDir(join(dshHome, 'tui-presence')),
+    };
+}
+/**
+ * Read one peer's records over SSH.
+ *
+ * `BatchMode=yes` matters: a peer whose key is missing must fail fast with an
+ * error in the overview rather than blocking the UI on a password prompt.
+ */
+export async function collectPeer(peer) {
+    const home = peer.dshHome ?? '$HOME/.dsh';
+    // cat of a glob that matches nothing would fail; guard it in the shell.
+    const remote = `d="${home}/tui-presence"; [ -d "$d" ] && cat "$d"/*.json 2>/dev/null || true`;
+    try {
+        const stdout = await ssh(peer.host, remote);
+        return { host: peer.host, local: false, records: parseRecords(stdout) };
+    }
+    catch (error) {
+        return {
+            host: peer.host,
+            local: false,
+            records: [],
+            error: describe(error),
+        };
+    }
+}
+/** Read every device in parallel; one slow peer must not hold up the rest. */
+export async function collectFleet(peers, dshHome = localDshHome()) {
+    const remote = await Promise.all(peers.map((peer) => collectPeer(peer)));
+    return [collectLocal(dshHome), ...remote];
+}
+/** Parse concatenated JSON records, tolerating whatever else is in the stream. */
+function parseRecords(stdout) {
+    const records = [];
+    // Records are written one JSON object per file with a trailing newline, so
+    // concatenation yields one object per line in practice; fall back to a
+    // brace scan if a peer wrote them pretty-printed.
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed === '' || !trimmed.startsWith('{'))
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (isPresenceRecord(parsed))
+                records.push(parsed);
+        }
+        catch {
+            // Ignore a partial line rather than losing the whole peer.
+        }
+    }
+    return records;
+}
+/** Run one non-interactive SSH command. */
+function ssh(host, command) {
+    return new Promise((resolve, reject) => {
+        execFile('ssh', [
+            '-o',
+            'BatchMode=yes',
+            '-o',
+            `ConnectTimeout=${String(Math.ceil(SSH_TIMEOUT_MS / 1000))}`,
+            host,
+            command,
+        ], { timeout: SSH_TIMEOUT_MS, encoding: 'utf8' }, (error, stdout, stderr) => {
+            if (error !== null) {
+                // ssh puts the useful line on stderr; node's own message is the whole
+                // command echoed back, which is noise in a one-line overview.
+                const detail = String(stderr)
+                    .split('\n')
+                    .map((line) => line.replace(/^ssh: /, '').trim())
+                    .find((line) => line !== '');
+                const timedOut = error.code === 'ETIMEDOUT';
+                reject(new Error(detail ?? (timedOut ? 'timed out' : 'unreachable')));
+                return;
+            }
+            resolve(String(stdout));
+        });
+    });
+}
+/** A one-line, human-readable form of anything thrown. */
+function describe(error) {
+    return error instanceof Error ? error.message : String(error);
+}