@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/dist/scripts/managed-dsh-run-port-proof.js

@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { ManagedDshRunPort } from '../src/booking-surface/managed-dsh-run-port.js';
+const workerPath = fileURLToPath(new URL('./fixtures/managed-dsh-worker-fixture.mjs', import.meta.url));
+const port = new ManagedDshRunPort({ workerPath, graceMs: 50 });
+const result = await port.run('fixture', { sessionId: 'managed-dsh-proof' });
+const pid = result.events[0].grandchildPid;
+assert.ok(Number.isInteger(pid) && pid > 0, 'fixture reports its grandchild pid');
+const started = Date.now();
+await port.close();
+assert.ok(Date.now() - started < 2_000, 'tree teardown is bounded');
+const deadline = Date.now() + 1_000;
+let alive = true;
+while (alive && Date.now() < deadline) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        alive = false;
+    }
+    if (alive)
+        await new Promise((resolve) => setTimeout(resolve, 25));
+}
+assert.equal(alive, false, `TERM-resistant grandchild ${pid} must be reaped with its worker tree`);
+assert.ok(existsSync(join(process.cwd(), 'node_modules/@deepseek-ai/dsh-subprocess-local')), 'proof uses installed dsh subprocess-local runtime');
+console.log('MANAGED DSH RUN PORT TREE PROOF: bounded close reaps TERM-resistant grandchild');
+const pendingWorkerPath = fileURLToPath(new URL('./fixtures/managed-dsh-pending-worker-fixture.mjs', import.meta.url));
+async function waitForFile(path, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (!existsSync(path)) {
+        if (Date.now() >= deadline)
+            throw new Error(`fixture marker did not appear: ${path}`);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+async function waitForFileText(path, expected, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (!existsSync(path) || readFileSync(path, 'utf8') !== expected) {
+        if (Date.now() >= deadline)
+            throw new Error(`fixture marker did not reach ${expected}: ${path}`);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+async function waitForDead(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return;
+        }
+        if (Date.now() >= deadline)
+            throw new Error(`fixture process ${pid} was not reaped`);
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+}
+async function bounded(promise, timeoutMs, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(label)), timeoutMs); }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function assertPendingRejected(settledPromise, expected, label) {
+    const settled = await bounded(settledPromise, 1_500, `${label}: pending requests did not settle`);
+    assert.equal(settled.length, expected, `${label}: every pending request settled`);
+    assert.ok(settled.every((entry) => entry.status === 'rejected'), `${label}: every pending request rejected`);
+}
+async function proveWorkerExitRejectsPending() {
+    const root = mkdtempSync(join(tmpdir(), 'gotry-managed-dsh-exit-'));
+    const pidFile = join(root, 'pid.json');
+    const requestFile = join(root, 'requests');
+    const statusFile = join(root, 'status.json');
+    const port = new ManagedDshRunPort({
+        workerPath: pendingWorkerPath,
+        graceMs: 50,
+        env: {
+            ...process.env,
+            MANAGED_DSH_FIXTURE_PID_FILE: pidFile,
+            MANAGED_DSH_FIXTURE_REQUEST_FILE: requestFile,
+            MANAGED_DSH_FIXTURE_STATUS_FILE: statusFile,
+            MANAGED_DSH_FIXTURE_EXIT_AFTER_REQUESTS: '3',
+            MANAGED_DSH_FIXTURE_EXIT_CODE: '23',
+        },
+    });
+    try {
+        await waitForFile(pidFile, 1_000);
+        const pending = [
+            port.run('first pending run', { sessionId: 'managed-dsh-exit-1' }),
+            port.run('second pending run', { sessionId: 'managed-dsh-exit-2' }),
+            port.warmup(),
+        ];
+        const settledPromise = Promise.allSettled(pending);
+        await waitForFileText(requestFile, '3', 1_000);
+        await assertPendingRejected(settledPromise, pending.length, 'worker exit');
+        await waitForFile(statusFile, 1_000);
+        const status = JSON.parse(readFileSync(statusFile, 'utf8'));
+        assert.equal(status.exitCode, 23, 'fixture exit code is recorded');
+        assert.equal(status.signal, null, 'fixture exited without a signal');
+        assert.ok(status.stderr.length <= 128, 'fixture stderr evidence is bounded');
+        assert.equal(status.stderr.includes('PRIVATE_'), false, 'fixture stderr evidence contains no sensitive marker');
+    }
+    finally {
+        await port.close().catch(() => undefined);
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+async function proveCloseRejectsPendingAndReapsTree() {
+    const root = mkdtempSync(join(tmpdir(), 'gotry-managed-dsh-close-'));
+    const pidFile = join(root, 'pid.json');
+    const requestFile = join(root, 'requests');
+    const port = new ManagedDshRunPort({
+        workerPath: pendingWorkerPath,
+        graceMs: 50,
+        env: { ...process.env, MANAGED_DSH_FIXTURE_PID_FILE: pidFile, MANAGED_DSH_FIXTURE_REQUEST_FILE: requestFile },
+    });
+    try {
+        await waitForFile(pidFile, 1_000);
+        const pids = JSON.parse(readFileSync(pidFile, 'utf8'));
+        assert.ok(Number.isInteger(pids.workerPid) && Number.isInteger(pids.grandchildPid), 'pending fixture reports its worker tree');
+        const pending = [
+            port.run('first close run', { sessionId: 'managed-dsh-close-1' }),
+            port.run('second close run', { sessionId: 'managed-dsh-close-2' }),
+            port.warmup(),
+        ];
+        const settledPromise = Promise.allSettled(pending);
+        await waitForFileText(requestFile, '3', 1_000);
+        const closeStarted = Date.now();
+        const closePromise = port.close();
+        assert.strictEqual(port.close(), closePromise, 'repeated close returns the same cleanup promise');
+        await assertPendingRejected(settledPromise, pending.length, 'caller close');
+        await closePromise;
+        assert.ok(Date.now() - closeStarted < 2_000, 'caller close and pending rejection are bounded');
+        await waitForDead(pids.workerPid, 1_000);
+        await waitForDead(pids.grandchildPid, 1_000);
+    }
+    finally {
+        await port.close().catch(() => undefined);
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+await proveWorkerExitRejectsPending();
+await proveCloseRejectsPendingAndReapsTree();
+console.log('MANAGED DSH RUN PORT PENDING PROOF: worker exit and caller close reject two runs plus warmup; tree cleanup remains bounded');

package/dist/scripts/managed-dsh-terminal-proof.js

@@ -0,0 +1,252 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
+import { ManagedDshRunPort } from '../src/booking-surface/managed-dsh-run-port.js';
+import { ManagedDshCleanupError } from '../src/booking-surface/managed-dsh-cleanup-diagnostic.js';
+const pendingWorkerPath = fileURLToPath(new URL('./fixtures/managed-dsh-pending-worker-fixture.mjs', import.meta.url));
+// Attach a rejection handler in the same turn as every operation that can reject.
+// This proof intentionally exercises real SDK promises, so it must not synthesize
+// a completed `done` promise or leave a rejected close/run promise unobserved.
+function observe(promise) {
+    return promise.then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason }));
+}
+async function bounded(promise, timeoutMs, label) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(label)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function reasonMessage(reason) {
+    return reason instanceof Error ? reason.message : String(reason);
+}
+async function rejectedWith(promise, expected, label) {
+    const outcome = await bounded(promise, 1_500, `${label}: promise did not settle`);
+    assert.equal(outcome.status, 'rejected', `${label}: promise must reject`);
+    const message = reasonMessage(outcome.reason);
+    assert.equal(message, expected, `${label}: stable public error`);
+}
+async function rejectedBeforeNextImmediate(promise, expected, label) {
+    let immediate;
+    try {
+        const outcome = await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                immediate = setImmediate(() => reject(new Error(`${label}: promise did not reject before next setImmediate`)));
+            }),
+        ]);
+        assert.equal(outcome.status, 'rejected', `${label}: promise must reject`);
+        assert.equal(reasonMessage(outcome.reason), expected, `${label}: stable public error`);
+    }
+    finally {
+        if (immediate)
+            clearImmediate(immediate);
+    }
+}
+async function waitForFile(path, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (!existsSync(path)) {
+        if (Date.now() >= deadline)
+            throw new Error(`fixture marker did not appear: ${path}`);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+async function waitForFileText(path, expected, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (!existsSync(path) || readFileSync(path, 'utf8') !== expected) {
+        if (Date.now() >= deadline)
+            throw new Error(`fixture marker did not reach ${expected}: ${path}`);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+}
+async function waitForDead(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            return;
+        }
+        if (Date.now() >= deadline)
+            throw new Error(`fixture process ${pid} was not reaped`);
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+}
+async function cleanup(port) {
+    if (!port)
+        return;
+    // Keep cleanup rejection observed even when an assertion fails earlier.
+    await bounded(observe(port.close()), 2_000, 'cleanup did not settle');
+}
+async function proveNaturalExitRejectsNewRequests() {
+    const root = mkdtempSync(join(tmpdir(), 'gotry-managed-dsh-terminal-exit-'));
+    const pidFile = join(root, 'pid.json');
+    const requestFile = join(root, 'requests');
+    const statusFile = join(root, 'status.json');
+    let port;
+    try {
+        port = new ManagedDshRunPort({
+            workerPath: pendingWorkerPath,
+            graceMs: 50,
+            env: {
+                ...process.env,
+                MANAGED_DSH_FIXTURE_PID_FILE: pidFile,
+                MANAGED_DSH_FIXTURE_REQUEST_FILE: requestFile,
+                MANAGED_DSH_FIXTURE_STATUS_FILE: statusFile,
+                MANAGED_DSH_FIXTURE_EXIT_AFTER_REQUESTS: '1',
+                MANAGED_DSH_FIXTURE_EXIT_CODE: '23',
+            },
+        });
+        await waitForFile(pidFile, 1_000);
+        const oldPending = observe(port.run('terminal exit pending run', { sessionId: 'managed-dsh-terminal-exit-old' }));
+        await waitForFileText(requestFile, '1', 1_000);
+        await rejectedWith(oldPending, 'managed DSH worker exited', 'natural exit pending run');
+        await waitForFile(statusFile, 1_000);
+        const status = JSON.parse(readFileSync(statusFile, 'utf8'));
+        assert.equal(status.exitCode, 23, 'fixture naturally exits with code 23');
+        assert.equal(status.signal, null, 'fixture natural exit has no signal');
+        assert.ok(status.stderr.length <= 128, 'fixture stderr evidence is bounded');
+        // Wait for the real handle.done rejection/settlement path above, then probe
+        // both public request methods after the worker has exited.
+        await rejectedBeforeNextImmediate(observe(port.run('terminal exit post run', { sessionId: 'managed-dsh-terminal-exit-new' })), 'managed DSH worker exited', 'natural exit new run');
+        await rejectedBeforeNextImmediate(observe(port.warmup()), 'managed DSH worker exited', 'natural exit new warmup');
+        const closePromise = port.close();
+        const repeatedClosePromise = port.close();
+        assert.strictEqual(repeatedClosePromise, closePromise, 'natural exit repeated close returns one cleanup promise');
+        assert.equal((await bounded(observe(closePromise), 2_000, 'natural exit close did not settle')).status, 'fulfilled', 'natural exit close succeeds');
+    }
+    finally {
+        await cleanup(port);
+        rmSync(root, { recursive: true, force: true });
+    }
+    console.log('PASS managed DSH terminal natural exit: old pending and post-exit run/warmup reject immediately');
+}
+async function proveExplicitCloseIsBoundedAndIdempotent() {
+    const root = mkdtempSync(join(tmpdir(), 'gotry-managed-dsh-terminal-close-'));
+    const pidFile = join(root, 'pid.json');
+    const requestFile = join(root, 'requests');
+    let port;
+    try {
+        port = new ManagedDshRunPort({
+            workerPath: pendingWorkerPath,
+            graceMs: 50,
+            env: {
+                ...process.env,
+                MANAGED_DSH_FIXTURE_PID_FILE: pidFile,
+                MANAGED_DSH_FIXTURE_REQUEST_FILE: requestFile,
+            },
+        });
+        await waitForFile(pidFile, 1_000);
+        const pids = JSON.parse(readFileSync(pidFile, 'utf8'));
+        assert.ok(Number.isInteger(pids.workerPid) && Number.isInteger(pids.grandchildPid), 'fixture reports worker tree');
+        const pending = [
+            observe(port.run('terminal close first run', { sessionId: 'managed-dsh-terminal-close-1' })),
+            observe(port.run('terminal close second run', { sessionId: 'managed-dsh-terminal-close-2' })),
+            observe(port.warmup()),
+        ];
+        await waitForFileText(requestFile, '3', 1_000);
+        const closePromise = port.close();
+        const repeatedClosePromise = port.close();
+        assert.strictEqual(repeatedClosePromise, closePromise, 'repeated close returns one cleanup promise');
+        const closeOutcome = observe(closePromise);
+        const repeatedOutcome = observe(repeatedClosePromise);
+        for (const [index, request] of pending.entries()) {
+            await rejectedWith(request, 'managed DSH run port closed', `explicit close old pending ${index + 1}`);
+        }
+        assert.equal((await bounded(closeOutcome, 2_000, 'explicit close did not settle')).status, 'fulfilled', 'explicit close succeeds');
+        assert.equal((await bounded(repeatedOutcome, 2_000, 'repeated close did not settle')).status, 'fulfilled', 'repeated close succeeds');
+        await rejectedWith(observe(port.run('terminal close post run', { sessionId: 'managed-dsh-terminal-close-new' })), 'managed DSH run port is closed', 'explicit close new run');
+        await rejectedWith(observe(port.warmup()), 'managed DSH run port is closed', 'explicit close new warmup');
+        await waitForDead(pids.workerPid, 1_000);
+        await waitForDead(pids.grandchildPid, 1_000);
+    }
+    finally {
+        await cleanup(port);
+        rmSync(root, { recursive: true, force: true });
+    }
+    console.log('PASS managed DSH terminal explicit close: pending rejection, idempotent close, signal cleanup, and closed guards');
+}
+async function proveSignalTerminationRejectsPending() {
+    const root = mkdtempSync(join(tmpdir(), 'gotry-managed-dsh-terminal-signal-'));
+    const pidFile = join(root, 'pid.json');
+    const requestFile = join(root, 'requests');
+    let port;
+    try {
+        port = new ManagedDshRunPort({
+            workerPath: pendingWorkerPath,
+            graceMs: 50,
+            env: { ...process.env, MANAGED_DSH_FIXTURE_PID_FILE: pidFile, MANAGED_DSH_FIXTURE_REQUEST_FILE: requestFile },
+        });
+        await waitForFile(pidFile, 1_000);
+        const pids = JSON.parse(readFileSync(pidFile, 'utf8'));
+        assert.ok(Number.isInteger(pids.workerPid) && Number.isInteger(pids.grandchildPid), 'signal fixture reports its worker tree');
+        const oldPending = observe(port.run('terminal signal pending run', { sessionId: 'managed-dsh-terminal-signal-old' }));
+        await waitForFileText(requestFile, '1', 1_000);
+        // Kill the real child from outside the port. This exercises the SDK's
+        // signal-shaped done resolution, rather than ManagedDshRunPort.close().
+        process.kill(pids.workerPid, 'SIGKILL');
+        await rejectedWith(oldPending, 'managed DSH worker exited', 'signal exit pending run');
+        await waitForDead(pids.workerPid, 1_000);
+        await rejectedBeforeNextImmediate(observe(port.run('terminal signal post run', { sessionId: 'managed-dsh-terminal-signal-new' })), 'managed DSH worker exited', 'signal exit new run');
+        await rejectedBeforeNextImmediate(observe(port.warmup()), 'managed DSH worker exited', 'signal exit new warmup');
+        const closePromise = port.close();
+        const repeatedClosePromise = port.close();
+        assert.strictEqual(repeatedClosePromise, closePromise, 'signal exit repeated close returns one cleanup promise');
+        assert.equal((await bounded(observe(closePromise), 2_000, 'signal exit close did not settle')).status, 'fulfilled', 'signal exit close succeeds');
+        await waitForDead(pids.grandchildPid, 1_000);
+    }
+    finally {
+        await cleanup(port);
+        rmSync(root, { recursive: true, force: true });
+    }
+    console.log('PASS managed DSH terminal signal: SIGKILL, post-signal guards, idempotent close, and tree cleanup');
+}
+async function proveSpawnFailureIsSanitized() {
+    const root = mkdtempSync(join(tmpdir(), 'gotry-managed-dsh-terminal-spawn-'));
+    const missingCwd = join(root, 'missing-cwd');
+    let port;
+    try {
+        // dsh-subprocess-local returns a live handle and rejects handle.done for a
+        // missing cwd; this uses that real failure path rather than a fake promise.
+        port = new ManagedDshRunPort({
+            cwd: missingCwd,
+            workerPath: pendingWorkerPath,
+            graceMs: 50,
+            env: { ...process.env },
+        });
+        await rejectedWith(observe(port.run('terminal spawn failure run', { sessionId: 'managed-dsh-terminal-spawn-failure' })), 'managed DSH worker failed', 'spawn failure run');
+        await rejectedBeforeNextImmediate(observe(port.warmup()), 'managed DSH worker failed', 'spawn failure warmup');
+        await rejectedBeforeNextImmediate(observe(port.run('terminal spawn failure post run', { sessionId: 'managed-dsh-terminal-spawn-failure-post' })), 'managed DSH worker failed', 'spawn failure post run');
+        const closePromise = port.close();
+        const repeatedClosePromise = port.close();
+        assert.strictEqual(repeatedClosePromise, closePromise, 'spawn failure repeated close is idempotent');
+        for (const [label, promise] of [['spawn failure close', closePromise], ['spawn failure repeated close', repeatedClosePromise]]) {
+            const outcome = await bounded(observe(promise), 2_000, `${label} did not settle`);
+            assert.equal(outcome.status, 'rejected', `${label} must reject`);
+            const reason = outcome.reason;
+            assert.ok(reason instanceof ManagedDshCleanupError, `${label} carries the typed cleanup diagnostic`);
+            assert.equal(reason.message.split(';')[0], 'managed DSH worker failed', `${label} stable public error`);
+        }
+    }
+    finally {
+        await cleanup(port);
+        rmSync(root, { recursive: true, force: true });
+    }
+    console.log('PASS managed DSH terminal spawn failure: real missing cwd and sanitized immediate guards');
+}
+await proveNaturalExitRejectsNewRequests();
+await proveExplicitCloseIsBoundedAndIdempotent();
+await proveSignalTerminationRejectsPending();
+await proveSpawnFailureIsSanitized();
+assert.ok(existsSync(join(process.cwd(), 'node_modules/@deepseek-ai/dsh-subprocess-local')), 'proof uses installed dsh subprocess-local runtime');
+console.log('MANAGED DSH TERMINAL PROOF: natural exit, explicit close, signal cleanup, and spawn failure are bounded and sanitized');