janissary 0.5.0

package/dist/database/index.js

@@ -0,0 +1,83 @@
+import { databaseFileExists as databaseFileExists, listDatabaseFiles, removeDatabaseFile, getConnection, closeConnection, } from '../connections.js';
+import { parseDatabaseCommand } from './parsing.js';
+export { parseDatabaseCommand } from './parsing.js';
+import { queryDatabase } from './query.js';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function createDatabase(name) {
+    const isExisted = databaseFileExists(name);
+    try {
+        getConnection(name);
+        return isExisted ? `Database "${name}" already exists.` : `Created sqlite database "${name}".`;
+    }
+    catch (error) {
+        return `Failed to create database "${name}": ${errorMessage(error)}`;
+    }
+}
+function deleteDatabase(name) {
+    closeConnection(name);
+    if (!databaseFileExists(name))
+        return `Database "${name}" does not exist.`;
+    try {
+        removeDatabaseFile(name);
+        return `Deleted sqlite database "${name}".`;
+    }
+    catch (error) {
+        return `Failed to delete database "${name}": ${errorMessage(error)}`;
+    }
+}
+function listDbs() {
+    const names = listDatabaseFiles();
+    return names.length > 0 ? names.join('\n') : 'No databases.';
+}
+/** Execute a `db ...` command and return the text to show in the transcript. */
+export function runDatabaseCommand(input) {
+    const parsed = parseDatabaseCommand(input);
+    if ('error' in parsed)
+        return parsed.error;
+    switch (parsed.action) {
+        case 'create': {
+            return createDatabase(parsed.name);
+        }
+        case 'delete': {
+            return deleteDatabase(parsed.name);
+        }
+        case 'list': {
+            return listDbs();
+        }
+        case 'query': {
+            return queryDatabase(parsed.name, parsed.query);
+        }
+    }
+}
+// Primer injected into an ACP agent so it understands the `db` grammar and can
+// drive an autonomous tool loop: it emits a command, the host runs it, and the
+// output is fed back until the agent answers without a command.
+export const DB_PRIMER = [
+    'This host CLI can manage SQLite databases via `db` commands. Syntax:',
+    '  db sqlite create <name>          # create an empty database',
+    '  db sqlite delete <name>          # delete a database',
+    '  db sqlite query  <name> <sql>    # run SQL against a database',
+    '  db sqlite list                   # list databases',
+    'Database names use letters, numbers, "-" and "_" only; the engine is always "sqlite".',
+    'To inspect or change a database, end your reply with exactly one `db` command on its',
+    'own final line (no code fence, nothing after it). The host runs it automatically and',
+    'returns the output to you, so you can issue further commands. When the task is done,',
+    'reply with the final answer and NO trailing `db` command.',
+    'Be concise: do not explain what you are doing. Only output `db` commands and the final answer.',
+].join('\n');
+/**
+ * Pull a proposed `db ...` command out of an agent reply, if present. Scans
+ * bottom-up (the primer asks for the command on the last line) and tolerates a
+ * surrounding code fence or a leading `$ `/`> ` prompt marker.
+ */
+export function extractDatabaseCommand(text) {
+    const lines = text.split('\n');
+    for (let index = lines.length - 1; index >= 0; index--) {
+        const line = lines[index].replace(/^[\s`$>]+/, '').replace(/`+\s*$/, '').trim();
+        if (/^db\s+sqlite\s+(create|delete|query|list)\b/i.test(line))
+            return line;
+    }
+    // not a db command
+}

package/dist/database/manager.js

@@ -0,0 +1,67 @@
+import { runDatabaseCommand, parseDatabaseCommand, extractDatabaseCommand, DB_PRIMER } from './index.js';
+import { isConnectionOpen, closeConnection, closeAllConnections, listOpenConnections } from '../connections.js';
+// Owns each tab's view of the SQLite databases it has opened, and acts as the controller's facade
+// over the global connection registry (connections.ts) and the `db` command surface (database.ts).
+// SQLite connections themselves are global; this manager attributes them to the tab(s) that ran a
+// `db` command against them — so a tab's connections panel reflects only the databases it opened —
+// and keeps that attribution in sync as databases are created, queried, deleted, or closed.
+export class DatabaseManager {
+    // Tab label → the SQLite database names that tab has opened (sorted, deduped).
+    tabConns = new Map();
+    // The instructions describing the `db` command surface, injected into the ACP agent's primer.
+    get primer() {
+        return DB_PRIMER;
+    }
+    // Run a `db` command on behalf of a tab, keeping that tab's tracked SQLite connections in sync so
+    // its connections panel reflects what it has open. `delete` forgets the connection; any opening
+    // command (create/query) records it once.
+    runInTab(label, command) {
+        const output = runDatabaseCommand(command);
+        const parsed = parseDatabaseCommand(command);
+        if (!('error' in parsed)) {
+            if (parsed.action === 'delete')
+                this.forgetConn(parsed.name);
+            else if (parsed.action !== 'list' && isConnectionOpen(parsed.name)) {
+                const current = this.tabConns.get(label) ?? [];
+                if (!current.includes(parsed.name))
+                    this.tabConns.set(label, [...current, parsed.name].toSorted((a, b) => a.localeCompare(b)));
+            }
+        }
+        return output;
+    }
+    // The SQLite databases a tab has opened that are still live (filtered against the global registry
+    // so a closed/deleted db drops out). Drives the per-tab connections panel and command recognition.
+    openDbs(label) {
+        return (this.tabConns.get(label) ?? []).filter(isConnectionOpen);
+    }
+    // A `db`-shaped command embedded in agent text (for the ACP tool loop), or undefined if none.
+    extract(text) {
+        return extractDatabaseCommand(text);
+    }
+    // Every globally open SQLite database (for the connections panel and completion).
+    listOpen() {
+        return listOpenConnections();
+    }
+    // Close one globally open SQLite connection by name; returns whether one was open (drives the
+    // `connection close sqlite` result message).
+    close(name) {
+        return closeConnection(name);
+    }
+    // Forget a tab's tracked connections (on tab close). The connections stay globally open.
+    forgetTab(label) {
+        this.tabConns.delete(label);
+    }
+    // Close every globally open SQLite connection and forget all per-tab attribution (last tab closed
+    // / app shutdown) — connections are global, so they're closed only when no tab remains.
+    closeAll() {
+        closeAllConnections();
+        this.tabConns.clear();
+    }
+    // Drop a database name from every tab's tracked connections (on `db delete`).
+    forgetConn(name) {
+        for (const [label, names] of this.tabConns) {
+            if (names.includes(name))
+                this.tabConns.set(label, names.filter((n) => n !== name));
+        }
+    }
+}

package/dist/database/parsing.js

@@ -0,0 +1,54 @@
+const VALID_NAME = /^[A-Za-z0-9_-]+$/;
+const USAGE = 'Usage: db sqlite <create|delete|query|list> [name] [query]';
+const ACTIONS = new Set(['create', 'delete', 'query', 'list']);
+function engineError(engine) {
+    return { error: `Unsupported engine "${engine}". Only "sqlite" is supported.` };
+}
+function nameError(name) {
+    return { error: `Invalid database name "${name}". Use letters, numbers, "-" and "_" only.` };
+}
+function unwrapQuotes(s) {
+    const q = s[0];
+    if (s.length >= 2 && (q === '"' || q === "'") && s.at(-1) === q) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+/** Parse a `db sqlite ...` command into an action. Pure — performs no I/O. */
+export function parseDatabaseCommand(input) {
+    const rest = input.trim().replace(/^db\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const [engineRaw, ...tail] = rest.split(/\s+/);
+    const engine = engineRaw.toLowerCase();
+    if (engine !== 'sqlite') {
+        return ACTIONS.has(engine) ? { error: USAGE } : engineError(engine);
+    }
+    const action = tail[0]?.toLowerCase();
+    if (!action)
+        return { error: USAGE };
+    if (action === 'list')
+        return { action: 'list' };
+    if (action === 'create' || action === 'delete') {
+        const name = tail[1];
+        if (!name)
+            return { error: `Usage: db sqlite ${action} <name>` };
+        if (!VALID_NAME.test(name))
+            return nameError(name);
+        return { action, name };
+    }
+    if (action === 'query') {
+        return parseQueryAction(rest);
+    }
+    return { error: USAGE };
+}
+function parseQueryAction(rest) {
+    const m = rest.match(/^sqlite\s+query\s+(\S+)\s+([\s\S]+)$/i);
+    if (!m)
+        return { error: 'Usage: db sqlite query <name> <sql>' };
+    const name = m[1];
+    if (!VALID_NAME.test(name))
+        return nameError(name);
+    const query = unwrapQuotes(m[2].trim());
+    return { action: 'query', name, query };
+}

package/dist/database/query.js

@@ -0,0 +1,41 @@
+import { databaseFileExists, getConnection, isConnectionOpen, } from '../connections.js';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatRows(rows) {
+    if (rows.length === 0)
+        return '(0 rows)';
+    const cols = Object.keys(rows[0]);
+    const cell = (v) => (v === null || v === undefined ? '' : String(v));
+    const widths = cols.map((c) => Math.max(c.length, ...rows.map((r) => cell(r[c]).length)));
+    const fmt = (cells) => cells.map((s, index) => s.padEnd(widths[index])).join('  ');
+    const header = fmt(cols);
+    const separator = widths.map((w) => '-'.repeat(w)).join('  ');
+    const body = rows.map((r) => fmt(cols.map((c) => cell(r[c]))));
+    const count = `(${rows.length} row${rows.length === 1 ? '' : 's'})`;
+    return [header, separator, ...body, '', count].join('\n');
+}
+const READ_QUERY = /^\s*(select|pragma|with|explain)\b/i;
+export function queryDatabase(name, query) {
+    if (!databaseFileExists(name) && !isConnectionOpen(name)) {
+        return `Database "${name}" does not exist. Create it with: db sqlite create ${name}`;
+    }
+    let database;
+    try {
+        database = getConnection(name);
+    }
+    catch (error) {
+        return `Failed to open database "${name}": ${errorMessage(error)}`;
+    }
+    try {
+        if (READ_QUERY.test(query)) {
+            const rows = database.prepare(query).all();
+            return formatRows(rows);
+        }
+        database.exec(query);
+        return 'OK.';
+    }
+    catch (error) {
+        return `Query error: ${errorMessage(error)}`;
+    }
+}

package/dist/database-manager.js

@@ -0,0 +1,67 @@
+import { runDatabaseCommand, parseDatabaseCommand, extractDatabaseCommand, DB_PRIMER } from './database.js';
+import { isConnectionOpen, closeConnection, closeAllConnections, listOpenConnections } from './connections.js';
+// Owns each tab's view of the SQLite databases it has opened, and acts as the controller's facade
+// over the global connection registry (connections.ts) and the `db` command surface (database.ts).
+// SQLite connections themselves are global; this manager attributes them to the tab(s) that ran a
+// `db` command against them — so a tab's connections panel reflects only the databases it opened —
+// and keeps that attribution in sync as databases are created, queried, deleted, or closed.
+export class DatabaseManager {
+    // Tab label → the SQLite database names that tab has opened (sorted, deduped).
+    tabConns = new Map();
+    // The instructions describing the `db` command surface, injected into the ACP agent's primer.
+    get primer() {
+        return DB_PRIMER;
+    }
+    // Run a `db` command on behalf of a tab, keeping that tab's tracked SQLite connections in sync so
+    // its connections panel reflects what it has open. `delete` forgets the connection; any opening
+    // command (create/query) records it once.
+    runInTab(label, command) {
+        const output = runDatabaseCommand(command);
+        const parsed = parseDatabaseCommand(command);
+        if (!('error' in parsed)) {
+            if (parsed.action === 'delete')
+                this.forgetConn(parsed.name);
+            else if (parsed.action !== 'list' && isConnectionOpen(parsed.name)) {
+                const current = this.tabConns.get(label) ?? [];
+                if (!current.includes(parsed.name))
+                    this.tabConns.set(label, [...current, parsed.name].toSorted((a, b) => a.localeCompare(b)));
+            }
+        }
+        return output;
+    }
+    // The SQLite databases a tab has opened that are still live (filtered against the global registry
+    // so a closed/deleted db drops out). Drives the per-tab connections panel and command recognition.
+    openDbs(label) {
+        return (this.tabConns.get(label) ?? []).filter(isConnectionOpen);
+    }
+    // A `db`-shaped command embedded in agent text (for the ACP tool loop), or undefined if none.
+    extract(text) {
+        return extractDatabaseCommand(text);
+    }
+    // Every globally open SQLite database (for the connections panel and completion).
+    listOpen() {
+        return listOpenConnections();
+    }
+    // Close one globally open SQLite connection by name; returns whether one was open (drives the
+    // `connection close sqlite` result message).
+    close(name) {
+        return closeConnection(name);
+    }
+    // Forget a tab's tracked connections (on tab close). The connections stay globally open.
+    forgetTab(label) {
+        this.tabConns.delete(label);
+    }
+    // Close every globally open SQLite connection and forget all per-tab attribution (last tab closed
+    // / app shutdown) — connections are global, so they're closed only when no tab remains.
+    closeAll() {
+        closeAllConnections();
+        this.tabConns.clear();
+    }
+    // Drop a database name from every tab's tracked connections (on `db delete`).
+    forgetConn(name) {
+        for (const [label, names] of this.tabConns) {
+            if (names.includes(name))
+                this.tabConns.set(label, names.filter((n) => n !== name));
+        }
+    }
+}

package/dist/database-parsing.js

@@ -0,0 +1,54 @@
+const VALID_NAME = /^[A-Za-z0-9_-]+$/;
+const USAGE = 'Usage: db sqlite <create|delete|query|list> [name] [query]';
+const ACTIONS = new Set(['create', 'delete', 'query', 'list']);
+function engineError(engine) {
+    return { error: `Unsupported engine "${engine}". Only "sqlite" is supported.` };
+}
+function nameError(name) {
+    return { error: `Invalid database name "${name}". Use letters, numbers, "-" and "_" only.` };
+}
+function unwrapQuotes(s) {
+    const q = s[0];
+    if (s.length >= 2 && (q === '"' || q === "'") && s.at(-1) === q) {
+        return s.slice(1, -1);
+    }
+    return s;
+}
+/** Parse a `db sqlite ...` command into an action. Pure — performs no I/O. */
+export function parseDatabaseCommand(input) {
+    const rest = input.trim().replace(/^db\b\s*/i, '').trim();
+    if (!rest)
+        return { error: USAGE };
+    const [engineRaw, ...tail] = rest.split(/\s+/);
+    const engine = engineRaw.toLowerCase();
+    if (engine !== 'sqlite') {
+        return ACTIONS.has(engine) ? { error: USAGE } : engineError(engine);
+    }
+    const action = tail[0]?.toLowerCase();
+    if (!action)
+        return { error: USAGE };
+    if (action === 'list')
+        return { action: 'list' };
+    if (action === 'create' || action === 'delete') {
+        const name = tail[1];
+        if (!name)
+            return { error: `Usage: db sqlite ${action} <name>` };
+        if (!VALID_NAME.test(name))
+            return nameError(name);
+        return { action, name };
+    }
+    if (action === 'query') {
+        return parseQueryAction(rest);
+    }
+    return { error: USAGE };
+}
+function parseQueryAction(rest) {
+    const m = rest.match(/^sqlite\s+query\s+(\S+)\s+([\s\S]+)$/i);
+    if (!m)
+        return { error: 'Usage: db sqlite query <name> <sql>' };
+    const name = m[1];
+    if (!VALID_NAME.test(name))
+        return nameError(name);
+    const query = unwrapQuotes(m[2].trim());
+    return { action: 'query', name, query };
+}

package/dist/database-query.js

@@ -0,0 +1,41 @@
+import { databaseFileExists, getConnection, isConnectionOpen, } from './connections.js';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatRows(rows) {
+    if (rows.length === 0)
+        return '(0 rows)';
+    const cols = Object.keys(rows[0]);
+    const cell = (v) => (v === null || v === undefined ? '' : String(v));
+    const widths = cols.map((c) => Math.max(c.length, ...rows.map((r) => cell(r[c]).length)));
+    const fmt = (cells) => cells.map((s, index) => s.padEnd(widths[index])).join('  ');
+    const header = fmt(cols);
+    const separator = widths.map((w) => '-'.repeat(w)).join('  ');
+    const body = rows.map((r) => fmt(cols.map((c) => cell(r[c]))));
+    const count = `(${rows.length} row${rows.length === 1 ? '' : 's'})`;
+    return [header, separator, ...body, '', count].join('\n');
+}
+const READ_QUERY = /^\s*(select|pragma|with|explain)\b/i;
+export function queryDatabase(name, query) {
+    if (!databaseFileExists(name) && !isConnectionOpen(name)) {
+        return `Database "${name}" does not exist. Create it with: db sqlite create ${name}`;
+    }
+    let database;
+    try {
+        database = getConnection(name);
+    }
+    catch (error) {
+        return `Failed to open database "${name}": ${errorMessage(error)}`;
+    }
+    try {
+        if (READ_QUERY.test(query)) {
+            const rows = database.prepare(query).all();
+            return formatRows(rows);
+        }
+        database.exec(query);
+        return 'OK.';
+    }
+    catch (error) {
+        return `Query error: ${errorMessage(error)}`;
+    }
+}

package/dist/database.js

@@ -0,0 +1,83 @@
+import { databaseFileExists as databaseFileExists, listDatabaseFiles, removeDatabaseFile, getConnection, closeConnection, } from './connections.js';
+import { parseDatabaseCommand } from './database-parsing.js';
+export { parseDatabaseCommand } from './database-parsing.js';
+import { queryDatabase } from './database-query.js';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function createDatabase(name) {
+    const isExisted = databaseFileExists(name);
+    try {
+        getConnection(name);
+        return isExisted ? `Database "${name}" already exists.` : `Created sqlite database "${name}".`;
+    }
+    catch (error) {
+        return `Failed to create database "${name}": ${errorMessage(error)}`;
+    }
+}
+function deleteDatabase(name) {
+    closeConnection(name);
+    if (!databaseFileExists(name))
+        return `Database "${name}" does not exist.`;
+    try {
+        removeDatabaseFile(name);
+        return `Deleted sqlite database "${name}".`;
+    }
+    catch (error) {
+        return `Failed to delete database "${name}": ${errorMessage(error)}`;
+    }
+}
+function listDbs() {
+    const names = listDatabaseFiles();
+    return names.length > 0 ? names.join('\n') : 'No databases.';
+}
+/** Execute a `db ...` command and return the text to show in the transcript. */
+export function runDatabaseCommand(input) {
+    const parsed = parseDatabaseCommand(input);
+    if ('error' in parsed)
+        return parsed.error;
+    switch (parsed.action) {
+        case 'create': {
+            return createDatabase(parsed.name);
+        }
+        case 'delete': {
+            return deleteDatabase(parsed.name);
+        }
+        case 'list': {
+            return listDbs();
+        }
+        case 'query': {
+            return queryDatabase(parsed.name, parsed.query);
+        }
+    }
+}
+// Primer injected into an ACP agent so it understands the `db` grammar and can
+// drive an autonomous tool loop: it emits a command, the host runs it, and the
+// output is fed back until the agent answers without a command.
+export const DB_PRIMER = [
+    'This host CLI can manage SQLite databases via `db` commands. Syntax:',
+    '  db sqlite create <name>          # create an empty database',
+    '  db sqlite delete <name>          # delete a database',
+    '  db sqlite query  <name> <sql>    # run SQL against a database',
+    '  db sqlite list                   # list databases',
+    'Database names use letters, numbers, "-" and "_" only; the engine is always "sqlite".',
+    'To inspect or change a database, end your reply with exactly one `db` command on its',
+    'own final line (no code fence, nothing after it). The host runs it automatically and',
+    'returns the output to you, so you can issue further commands. When the task is done,',
+    'reply with the final answer and NO trailing `db` command.',
+    'Be concise: do not explain what you are doing. Only output `db` commands and the final answer.',
+].join('\n');
+/**
+ * Pull a proposed `db ...` command out of an agent reply, if present. Scans
+ * bottom-up (the primer asks for the command on the last line) and tolerates a
+ * surrounding code fence or a leading `$ `/`> ` prompt marker.
+ */
+export function extractDatabaseCommand(text) {
+    const lines = text.split('\n');
+    for (let index = lines.length - 1; index >= 0; index--) {
+        const line = lines[index].replace(/^[\s`$>]+/, '').replace(/`+\s*$/, '').trim();
+        if (/^db\s+sqlite\s+(create|delete|query|list)\b/i.test(line))
+            return line;
+    }
+    // not a db command
+}

package/dist/datetime.js

@@ -0,0 +1,15 @@
+export function getDateStr() {
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = String(now.getMonth() + 1).padStart(2, '0');
+    const d = String(now.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+}
+export function getTimeStr() {
+    const now = new Date();
+    const h = String(now.getHours()).padStart(2, '0');
+    const m = String(now.getMinutes()).padStart(2, '0');
+    const s = String(now.getSeconds()).padStart(2, '0');
+    const ms = String(now.getMilliseconds()).padStart(3, '0');
+    return `${h}:${m}:${s}.${ms}`;
+}

package/dist/editor/save.js

@@ -0,0 +1,27 @@
+import { statSync, writeFileSync } from 'node:fs';
+import { humanSize } from '../openers/size.js';
+import { messageBus } from '../bus.js';
+// Write an editor tab's buffer back to disk. `url` is the tab's `/open/<id>` ref, resolved
+// through the open-file allow-list — the client can only ever write to files the user explicitly
+// opened. Throws on an unknown ref or a write failure; the RPC layer turns that into an error
+// reply for the client's save feedback.
+export function saveFile(managers, url, content) {
+    const id = url.startsWith('/open/') ? url.slice('/open/'.length) : '';
+    const filePath = id ? managers.tab.openFilePath(id) : undefined;
+    if (!filePath)
+        throw new Error(`saveFile: unknown file ref "${url}"`);
+    writeFileSync(filePath, content, 'utf8');
+    // Refresh the owning tab's displayed size from the file's new on-disk size.
+    const stat = statSync(filePath);
+    const tab = managers.tab.tabs.find((t) => t.editor?.url === url);
+    if (tab?.editor)
+        tab.editor = { ...tab.editor, size: humanSize(stat.size) };
+    // The content is now canonical on disk, so any transient draft is superseded — drop it.
+    if (tab)
+        tab.editorDraft = undefined;
+    // Move the watcher's baseline forward first, so its own `fs.watch` event for this write isn't
+    // mistaken for an external change.
+    if (tab)
+        managers.editorWatch.markSaved(tab.label, stat.mtimeMs);
+    messageBus.emit('state', { type: 'dirty' });
+}

package/dist/editor/sync.js

@@ -0,0 +1,10 @@
+// Cache an editor tab's in-progress (unsaved) buffer as transient draft state on the tab. `url`
+// is the tab's `/open/<id>` ref, matched the same way saveFile's handler resolves its tab — but
+// unlike saveFile this never touches the filesystem or the open-file allow-list; it only writes
+// the in-memory `editorDraft`. An unresolvable `url` (e.g. a tab closed mid-debounce) is a no-op,
+// never an error.
+export function syncEditorBuffer(managers, url, content) {
+    const tab = managers.tab.tabs.find((t) => t.editor?.url === url);
+    if (tab)
+        tab.editorDraft = { content, updatedAt: Date.now() };
+}

package/dist/editor/watch-manager.js

@@ -0,0 +1,84 @@
+import { watch, statSync } from 'node:fs';
+import { messageBus } from '../bus.js';
+const DEBOUNCE_MS = 100;
+// Watches an open editor tab's underlying file for changes made by other processes, keyed by tab
+// label. `markSaved` moves the baseline mtime forward before the write's own `fs.watch` event
+// arrives, so the app's own saves never appear as an external change.
+export class EditorWatchManager {
+    managers;
+    tabs = new Map();
+    constructor(managers) {
+        this.managers = managers;
+    }
+    watch(label, filePath) {
+        this.unwatch(label);
+        let baselineMtimeMs;
+        try {
+            baselineMtimeMs = statSync(filePath).mtimeMs;
+        }
+        catch {
+            return;
+        }
+        try {
+            const watcher = watch(filePath, () => this.scheduleCheck(label));
+            this.tabs.set(label, { filePath, watcher, baselineMtimeMs });
+        }
+        catch {
+            // Exotic filesystems, fd limits, races — the editor still works, just without live reload.
+        }
+    }
+    // Move the baseline forward after the app's own write, so the resulting `fs.watch` event isn't
+    // mistaken for an external change.
+    markSaved(label, mtimeMs) {
+        const state = this.tabs.get(label);
+        if (state)
+            state.baselineMtimeMs = mtimeMs;
+    }
+    closeTab(label) {
+        this.unwatch(label);
+    }
+    dispose() {
+        for (const label of this.tabs.keys())
+            this.unwatch(label);
+    }
+    unwatch(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.debounce)
+            clearTimeout(state.debounce);
+        try {
+            state.watcher.close();
+        }
+        catch { /* already gone */ }
+        this.tabs.delete(label);
+    }
+    scheduleCheck(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        if (state.debounce)
+            clearTimeout(state.debounce);
+        state.debounce = setTimeout(() => this.check(label), DEBOUNCE_MS);
+    }
+    check(label) {
+        const state = this.tabs.get(label);
+        if (!state)
+            return;
+        let mtimeMs;
+        try {
+            mtimeMs = statSync(state.filePath).mtimeMs;
+        }
+        catch {
+            return;
+        }
+        if (mtimeMs === state.baselineMtimeMs)
+            return;
+        state.baselineMtimeMs = mtimeMs;
+        const tab = this.managers.tab.tabs.find((t) => t.label === label);
+        if (!tab?.editor)
+            return;
+        tab.editor = { ...tab.editor, mtimeMs };
+        messageBus.emit('state', { type: 'dirty' });
+    }
+}

package/dist/editor-save.js

@@ -0,0 +1,24 @@
+import { statSync, writeFileSync } from 'node:fs';
+import { humanSize } from './openers/size.js';
+import { messageBus } from './bus.js';
+// Write an editor tab's buffer back to disk. `url` is the tab's `/open/<id>` ref, resolved
+// through the open-file allow-list — the client can only ever write to files the user explicitly
+// opened. Throws on an unknown ref or a write failure; the RPC layer turns that into an error
+// reply for the client's save feedback.
+export function saveFile(managers, url, content) {
+    const id = url.startsWith('/open/') ? url.slice('/open/'.length) : '';
+    const filePath = id ? managers.tab.openFilePath(id) : undefined;
+    if (!filePath)
+        throw new Error(`saveFile: unknown file ref "${url}"`);
+    writeFileSync(filePath, content, 'utf8');
+    // Refresh the owning tab's displayed size from the file's new on-disk size.
+    const stat = statSync(filePath);
+    const tab = managers.tab.tabs.find((t) => t.editor?.url === url);
+    if (tab?.editor)
+        tab.editor = { ...tab.editor, size: humanSize(stat.size) };
+    // Move the watcher's baseline forward first, so its own `fs.watch` event for this write isn't
+    // mistaken for an external change.
+    if (tab)
+        managers.editorWatch.markSaved(tab.label, stat.mtimeMs);
+    messageBus.emit('state', { type: 'dirty' });
+}