dominds 0.1.0

package/dist/server.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+/**
+ * Module: server
+ *
+ * HTTP/WebSocket server for both development and production modes:
+ * - Serves static files with MIME detection and SPA fallback (production)
+ * - Provides `/api/*` endpoints and `/ws` WebSocket communication
+ * - CLI bootstrap with optional cwd/port/host/mode parameters
+ * - Development mode: `tsx --watch src/server.ts -p 5556 --mode dev`
+ * - Production mode: `node dist/server.js` (default port 5666)
+ */
+const path = __importStar(require("path"));
+const dialog_run_state_1 = require("./dialog-run-state");
+const driver_1 = require("./llm/driver");
+const log_1 = require("./log");
+const supervisor_1 = require("./mcp/supervisor");
+const auth_1 = require("./server/auth");
+const server_core_1 = require("./server/server-core");
+const websocket_handler_1 = require("./server/websocket-handler");
+const runtime_language_1 = require("./shared/runtime-language");
+require("./tools/builtins");
+const log = (0, log_1.createLogger)('server');
+// Setup unhandled rejection handler to capture crashes
+process.on('unhandledRejection', (reason, promise) => {
+    log.error('Unhandled Rejection at:', promise);
+    log.error('Reason:', reason instanceof Error ? reason : new Error(String(reason)));
+    log.error('Stack trace:', (reason instanceof Error && reason.stack) || 'No stack trace available');
+    // Optionally, we could exit the process here with code 1
+    // But in development, we might want to keep running
+});
+// Setup uncaught exception handler
+process.on('uncaughtException', (error) => {
+    log.error('Uncaught Exception:', error);
+    log.error('Stack trace:', error.stack);
+    // Optionally, exit with code 1
+    // process.exit(1);
+});
+function parseArgs(argv) {
+    const out = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '-C' || a === '--chdir') {
+            out['C'] = argv[i + 1];
+            i++;
+            continue;
+        }
+        if (a === '-p' || a === '--port') {
+            out['p'] = argv[i + 1];
+            i++;
+            continue;
+        }
+        if (a === '-H' || a === '--host') {
+            out['H'] = argv[i + 1];
+            i++;
+            continue;
+        }
+        if (a === '--mode') {
+            out['mode'] = argv[i + 1];
+            i++;
+            continue;
+        }
+    }
+    return out;
+}
+async function startServer(opts = {}) {
+    const { language: resolvedLanguage, source } = (0, runtime_language_1.resolveWorkLanguage)({ env: process.env });
+    (0, runtime_language_1.setWorkLanguage)(resolvedLanguage);
+    // Get port and host from options
+    const port = opts.port || (opts.mode === 'dev' ? 5556 : 5666);
+    const host = opts.host || '127.0.0.1';
+    const mode = opts.mode || 'prod';
+    log.info(`Starting server in ${mode} mode on ${host}:${port} (working language: ${(0, runtime_language_1.getWorkLanguage)()} from ${source})`);
+    // WebSocket clients set
+    const clients = new Set();
+    // Create server configuration
+    const config = {
+        mode: mode === 'dev' ? 'development' : 'production',
+        staticRoot: 'dist/static',
+        host,
+        port,
+        clients,
+        auth: (0, auth_1.computeAuthConfig)({
+            mode: mode === 'dev' ? 'development' : 'production',
+            env: process.env,
+        }),
+    };
+    const auth = config.auth ?? { kind: 'disabled' };
+    // Create HTTP server
+    const httpServer = (0, server_core_1.createHttpServer)(config);
+    // Setup WebSocket server
+    (0, websocket_handler_1.setupWebSocketServer)(httpServer.getHttpServer(), clients, config.auth ?? { kind: 'disabled' }, (0, runtime_language_1.getWorkLanguage)());
+    // MCP is best-effort: startup must not be blocked by MCP config/server issues.
+    (0, supervisor_1.startMcpSupervisor)();
+    // Crash recovery: any dialogs left in "proceeding" state are surfaced as interrupted/resumable.
+    await (0, dialog_run_state_1.reconcileRunStatesAfterRestart)();
+    // Start backend driver loop (non-blocking)
+    void (0, driver_1.runBackendDriver)();
+    // Start listening
+    await httpServer.start();
+    return { httpServer, auth, host, port, mode };
+}
+// Main function for CLI execution
+async function main() {
+    const cliArgs = parseArgs(process.argv.slice(2));
+    // Handle working directory change from -C flag
+    const wsDir = cliArgs['C'];
+    if (wsDir) {
+        // Resolve to absolute path before changing directory
+        const absoluteWsDir = path.isAbsolute(wsDir) ? wsDir : path.resolve(process.cwd(), wsDir);
+        try {
+            process.chdir(wsDir);
+        }
+        catch (err) {
+            log.warn(`Failed to change working directory to ${wsDir}:`, err);
+        }
+    }
+    // Get port, host, and mode from CLI args
+    const port = cliArgs['p'] ? Number(cliArgs['p']) : undefined;
+    const host = cliArgs['H'] || undefined;
+    const mode = cliArgs['mode'] || undefined;
+    await startServer({ port, host, mode });
+}
+// Start server if this file is run directly
+if (require.main === module) {
+    main().catch((error) => {
+        log.error('Web UI startup failed', error);
+        process.exit(1);
+    });
+}

package/dist/shared/async-fifo-mutex.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncFifoMutex = void 0;
+/**
+ * Async FIFO mutex (fair queue).
+ *
+ * Used for per-dialog and per-dialog-tree critical sections, keyed by dialog ID.
+ */
+class AsyncFifoMutex {
+    constructor() {
+        this.locked = false;
+        this.waiters = [];
+    }
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return () => this.release();
+        }
+        await new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+        return () => this.release();
+    }
+    isLocked() {
+        return this.locked;
+    }
+    release() {
+        const next = this.waiters.shift();
+        if (next) {
+            next();
+            return;
+        }
+        this.locked = false;
+    }
+}
+exports.AsyncFifoMutex = AsyncFifoMutex;

package/dist/shared/diligence.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DILIGENCE_FALLBACK_TEXT = exports.DEFAULT_DILIGENCE_PUSH_MAX = void 0;
+exports.DEFAULT_DILIGENCE_PUSH_MAX = 3;
+exports.DILIGENCE_FALLBACK_TEXT = {
+    zh: [
+        '除非确实需要人类用户介入，请继续你的工作。',
+        '',
+        '作为智能体团队成员，你该诉请（`!?@<teammate-callsign>`）队友完成的事儿千万别自己干，你自己的事儿能自己动手推进的就绝不要麻烦人类。',
+        '',
+        '不该或者不能自主继续工作时，你应该使用 `!?@human` 诉请人类确认相关问题或者指出工作方向。',
+    ].join('\n'),
+    en: [
+        'Unless you truly need the human user to intervene, keep working.',
+        '',
+        'As an agent team member: if it’s something you should ask a teammate (`!?@<teammate-callsign>`) to do, do not do it yourself; and for things you can advance on your own, do not bother the human.',
+        '',
+        'When you should not or cannot continue autonomously, use `!?@human` to ask the human to confirm the relevant questions or provide direction.',
+    ].join('\n'),
+};

package/dist/shared/dotenv.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRtwsDotenv = loadRtwsDotenv;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function isEnvKeyValid(key) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function unescapeDoubleQuoted(value) {
+    let out = '';
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (ch !== '\\') {
+            out += ch;
+            continue;
+        }
+        const next = value[i + 1];
+        if (next === undefined) {
+            out += '\\';
+            continue;
+        }
+        i++;
+        if (next === 'n')
+            out += '\n';
+        else if (next === 'r')
+            out += '\r';
+        else if (next === 't')
+            out += '\t';
+        else if (next === '\\')
+            out += '\\';
+        else if (next === '"')
+            out += '"';
+        else
+            out += next;
+    }
+    return out;
+}
+function stripInlineCommentFromUnquotedValue(raw) {
+    // Strip `# ...` only when it is preceded by whitespace.
+    for (let i = 0; i < raw.length; i++) {
+        const ch = raw[i];
+        if (ch !== '#')
+            continue;
+        if (i === 0)
+            return '';
+        const prev = raw[i - 1];
+        if (prev === ' ' || prev === '\t')
+            return raw.slice(0, i).trimEnd();
+    }
+    return raw.trimEnd();
+}
+function parseLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+        return { kind: 'skip' };
+    if (trimmed.startsWith('#'))
+        return { kind: 'skip' };
+    const withoutExport = trimmed.startsWith('export ')
+        ? trimmed.slice('export '.length).trim()
+        : trimmed;
+    const equalsIndex = withoutExport.indexOf('=');
+    if (equalsIndex < 0)
+        return { kind: 'error', reason: 'missing_equals' };
+    const rawKey = withoutExport.slice(0, equalsIndex).trim();
+    if (rawKey.length === 0)
+        return { kind: 'error', reason: 'empty_key' };
+    if (!isEnvKeyValid(rawKey))
+        return { kind: 'error', reason: 'invalid_key' };
+    let rawValue = withoutExport.slice(equalsIndex + 1).trim();
+    if (rawValue.length >= 2 && rawValue.startsWith('"') && rawValue.endsWith('"')) {
+        rawValue = unescapeDoubleQuoted(rawValue.slice(1, -1));
+    }
+    else if (rawValue.length >= 2 && rawValue.startsWith("'") && rawValue.endsWith("'")) {
+        rawValue = rawValue.slice(1, -1);
+    }
+    else {
+        rawValue = stripInlineCommentFromUnquotedValue(rawValue);
+    }
+    return { kind: 'entry', key: rawKey, value: rawValue };
+}
+function loadRtwsDotenv(params) {
+    const cwd = params && typeof params.cwd === 'string' ? params.cwd : process.cwd();
+    const files = ['.env', '.env.local'];
+    const loadedFiles = [];
+    const errors = [];
+    for (const file of files) {
+        const absPath = path.join(cwd, file);
+        if (!fs.existsSync(absPath))
+            continue;
+        loadedFiles.push(file);
+        const content = fs.readFileSync(absPath, 'utf8');
+        const lines = content.split(/\r?\n/);
+        for (let i = 0; i < lines.length; i++) {
+            const raw = lines[i];
+            const parsed = parseLine(raw);
+            if (parsed.kind === 'skip')
+                continue;
+            if (parsed.kind === 'error') {
+                errors.push({ file, lineNumber: i + 1, raw, reason: parsed.reason });
+                continue;
+            }
+            if (parsed.kind === 'entry') {
+                process.env[parsed.key] = parsed.value;
+                continue;
+            }
+            const _exhaustive = parsed;
+            throw new Error(`Unexpected dotenv parse result: ${String(_exhaustive)}`);
+        }
+    }
+    return { cwd, loadedFiles, errors };
+}

package/dist/shared/evt.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Event processing constructs equivalent to Edh's:
+ * - PubChan: write-only broadcast channel
+ * - SubChan: read-only subscriber channel
+ * - EventSink: event source with sequence and most-recent value, streaming support
+ *
+ * Notes:
+ * - PubChan behaves like a broadcast channel: if there is no SubChan reading, writes are effectively dropped
+ * - SubChan buffers unboundedly relative to its own consumption speed
+ * - EndOfStream sentinel signals termination of streams
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSink = exports.SubChan = exports.PubChan = exports.EndOfStream = void 0;
+exports.createPubChan = createPubChan;
+exports.createSubChan = createSubChan;
+exports.createEventSink = createEventSink;
+exports.EndOfStream = Symbol('EndOfStream');
+/**
+ * A small "deferred" helper to build a promise that can be resolved externally.
+ */
+function deferred() {
+    let resolve;
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    return { promise, resolve };
+}
+/**
+ * PubChan: publisher's write-only channel.
+ * Internally maintains a linked list of deferred promises to form a stream.
+ */
+class PubChan {
+    constructor() {
+        // The head of the chain: a deferred whose promise yields [ev, nextPromise]
+        this.nxt = deferred();
+        this.writes = 0;
+    }
+    /**
+     * Write an event into the channel.
+     * Subsequent readers will observe it in order.
+     */
+    write(ev) {
+        const next = deferred();
+        // Resolve current node with [event, nextPromise], then advance head
+        this.nxt.resolve([ev, next.promise]);
+        this.nxt = next;
+        this.writes += 1;
+    }
+    /**
+     * Expose current next promise for SubChan to adopt.
+     * Consumers should typically not use this directly.
+     */
+    get nextPromise() {
+        return this.nxt.promise;
+    }
+}
+exports.PubChan = PubChan;
+/**
+ * SubChan: subscriber's read-only channel.
+ * Holds its own pointer into the shared stream chain, thus buffering
+ * independently of other subscribers.
+ */
+class SubChan {
+    constructor(pub) {
+        this.reads = 0;
+        this.nxtP = pub.nextPromise;
+        const cancelDefer = deferred();
+        this.cancelled = cancelDefer.promise;
+        this.cancel = () => cancelDefer.resolve();
+    }
+    /**
+     * Read the next available value (could be EndOfStream).
+     * Caller may check ev === EndOfStream to detect eos.
+     */
+    async read() {
+        // If cancelled, return EndOfStream immediately
+        const raceResult = await Promise.race([this.cancelled, this.nxtP]);
+        if (raceResult === undefined) {
+            return exports.EndOfStream;
+        }
+        const [ev, nextP] = raceResult;
+        this.nxtP = nextP;
+        this.reads += 1;
+        return ev;
+    }
+    /**
+     * Async iterator over values until EndOfStream or cancellation.
+     */
+    stream() {
+        let nxtP = this.nxtP;
+        return (async function* (self) {
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const result = await Promise.race([self.cancelled, nxtP]);
+                // If cancelled (undefined), return immediately
+                if (result === undefined) {
+                    return;
+                }
+                const [ev, nextP] = result;
+                nxtP = self.nxtP = nextP;
+                if (ev === exports.EndOfStream)
+                    return;
+                yield ev;
+            }
+        })(this);
+    }
+}
+exports.SubChan = SubChan;
+/**
+ * EventSink: holds sequence, most recent value, and a PubChan.
+ * Provides stream(), one_more(), and run_producer() helpers.
+ */
+class EventSink {
+    constructor() {
+        this.seqn = 0;
+        this.mrv = null;
+        this.chan = new PubChan();
+    }
+    get eos() {
+        return this.mrv === exports.EndOfStream;
+    }
+    /**
+     * Publish an event. Increments sequence (wraps int64 max to 1).
+     * Ignores repeated EndOfStream publications after the first one.
+     */
+    publish(ev) {
+        if (ev === exports.EndOfStream && this.mrv === exports.EndOfStream) {
+            // Already published EndOfStream, ignore repeated attempts
+            return;
+        }
+        if (this.seqn >= 9223372036854775807) {
+            this.seqn = 1;
+        }
+        else {
+            this.seqn += 1;
+        }
+        this.mrv = ev;
+        this.chan.write(ev);
+    }
+    /**
+     * Await exactly one more item from the stream unless already at eos.
+     * If already eos after at least one event, returns EndOfStream immediately.
+     */
+    async one_more() {
+        if (this.seqn > 0 && this.mrv === exports.EndOfStream) {
+            return exports.EndOfStream;
+        }
+        // Peek the next from channel's head
+        const [ev] = await this.chan.nextPromise;
+        return ev;
+    }
+    /**
+     * Async iterator: yields the most recent value first (if any and not eos),
+     * then continues with subsequent events until EndOfStream.
+     */
+    stream() {
+        // Capture stream state at call time: capture the current most recent value and
+        // promise chain position immediately when this method is invoked. This prevents
+        // race conditions where events could be missed if we captured state when the
+        // returned generator starts iterating (which might be much later).
+        const yield1st = this.mrv;
+        const shouldYield1st = this.seqn > 0;
+        let nxtP = this.chan.nextPromise;
+        return (async function* () {
+            if (shouldYield1st) {
+                if (yield1st === exports.EndOfStream)
+                    return;
+                // yield the most recent first
+                yield yield1st;
+            }
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const [ev, nextP] = await Promise.resolve(nxtP);
+                if (ev === exports.EndOfStream)
+                    return;
+                yield ev;
+                nxtP = nextP;
+            }
+        })();
+    }
+}
+exports.EventSink = EventSink;
+/**
+ * Helpers to create channels/sinks
+ */
+function createPubChan() {
+    return new PubChan();
+}
+function createSubChan(pub) {
+    return new SubChan(pub);
+}
+function createEventSink() {
+    return new EventSink();
+}