@theaileverage/marionette 0.2.0 → 0.2.2

package/dist/herdr-transport.js

@@ -0,0 +1,232 @@
+import net from 'node:net';
+import { randomUUID } from 'node:crypto';
+import { isAbsolute } from 'node:path';
+export class HerdrError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'HerdrError';
+    }
+}
+export function validateSocketPath(path) {
+    if (!isAbsolute(path) && !/^\\\\[.?]\\pipe\\[^\\]/.test(path))
+        throw new TypeError('An absolute Herdr socket path or Windows named pipe is required');
+}
+export function validateTimeout(value) {
+    if (value !== null && (!Number.isFinite(value) || value <= 0 || value > 2147483647))
+        throw new TypeError('timeoutMs must be a positive bounded duration or null');
+}
+function limit(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new TypeError(`${name} must be a positive integer`);
+    return value;
+}
+/** Internal, single-reader NDJSON connection. JSON reads and binary writes stay separate. */
+export class JsonConnection {
+    options;
+    id = randomUUID();
+    closed;
+    resolveClosed;
+    rejectClosed;
+    socket;
+    buffer = '';
+    queue = [];
+    queuedBytes = 0;
+    reader;
+    writes = new Set();
+    ended = false;
+    failure;
+    explicitClose = false;
+    maxMessageBytes;
+    maxQueuedEvents;
+    maxQueuedBytes;
+    abort;
+    constructor(socketPath, options = {}) {
+        this.options = options;
+        validateSocketPath(socketPath);
+        this.maxMessageBytes = limit(options.maxResponseBytes ?? 32 * 1024 * 1024, 'maxResponseBytes');
+        this.maxQueuedEvents = limit(options.maxQueuedEvents ?? 1024, 'maxQueuedEvents');
+        this.maxQueuedBytes = limit(options.maxQueuedBytes ?? this.maxMessageBytes, 'maxQueuedBytes');
+        if (options.signal?.aborted)
+            throw new HerdrError('herdr_aborted', 'Herdr operation was aborted');
+        this.closed = new Promise((resolve, reject) => {
+            this.resolveClosed = resolve;
+            this.rejectClosed = reject;
+        });
+        // Consumers may observe this promise; an unobserved stream error must not crash Node.
+        void this.closed.catch(() => { });
+        this.socket = net.createConnection(socketPath);
+        this.socket.setEncoding('utf8');
+        this.abort = () => this.fail(new HerdrError('herdr_aborted', 'Herdr operation was aborted'), true);
+        options.signal?.addEventListener('abort', this.abort, { once: true });
+        this.socket.on('error', (error) => this.fail(new HerdrError('herdr_unavailable', error.message)));
+        this.socket.on('close', () => {
+            this.ended = true;
+            this.detachAbort();
+            this.rejectWrites(this.error());
+            if (this.failure || !this.explicitClose)
+                this.rejectClosed(this.error());
+            else
+                this.resolveClosed();
+            this.deliver();
+        });
+        this.socket.on('data', (data) => this.receive(data));
+    }
+    error() {
+        return (this.failure ??
+            new HerdrError('herdr_disconnected', 'Herdr disconnected before acknowledgement or stream completion'));
+    }
+    detachAbort() {
+        this.options.signal?.removeEventListener('abort', this.abort);
+    }
+    rejectWrites(error) {
+        for (const reject of this.writes)
+            reject(error);
+        this.writes.clear();
+    }
+    fail(error, discard = false) {
+        if (this.explicitClose)
+            return;
+        this.failure ??= error;
+        this.ended = true;
+        this.buffer = '';
+        if (discard) {
+            this.queue = [];
+            this.queuedBytes = 0;
+        }
+        this.detachAbort();
+        this.socket.destroy();
+        this.rejectWrites(this.failure);
+        this.deliver();
+    }
+    close() {
+        this.explicitClose = true;
+        this.ended = true;
+        this.buffer = '';
+        this.queue = [];
+        this.queuedBytes = 0;
+        this.detachAbort();
+        this.socket.destroy();
+        this.rejectWrites(this.error());
+        this.deliver();
+    }
+    deliver() {
+        if (!this.reader)
+            return;
+        const reader = this.reader;
+        if (this.failure) {
+            this.reader = undefined;
+            reader.reject(this.failure);
+            return;
+        }
+        const next = this.queue.shift();
+        if (next) {
+            this.reader = undefined;
+            this.queuedBytes -= next.bytes;
+            reader.resolve(next.value);
+        }
+        else if (this.ended) {
+            this.reader = undefined;
+            if (this.explicitClose)
+                reader.resolve(undefined);
+            else
+                reader.reject(this.error());
+        }
+    }
+    receive(data) {
+        if (this.ended)
+            return;
+        this.buffer += data;
+        let index;
+        while ((index = this.buffer.indexOf('\n')) >= 0) {
+            const line = this.buffer.slice(0, index);
+            this.buffer = this.buffer.slice(index + 1);
+            const bytes = Buffer.byteLength(line);
+            if (bytes > this.maxMessageBytes)
+                return this.fail(new HerdrError('herdr_response_too_large', 'Herdr message exceeded maxResponseBytes'), true);
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch (error) {
+                return this.fail(new HerdrError('herdr_invalid_response', String(error)), true);
+            }
+            // Each connection owns one request; graphics replies append a frame identifier.
+            if (value?.id !== undefined &&
+                value.id !== this.id &&
+                !String(value.id).startsWith(this.id + ':'))
+                continue;
+            if (value?.error)
+                return this.fail(new HerdrError(value.error.code, value.error.message), true);
+            if (this.queue.length >= this.maxQueuedEvents ||
+                this.queuedBytes + bytes > this.maxQueuedBytes)
+                return this.fail(new HerdrError('herdr_stream_overflow', 'Herdr consumer fell behind; stream closed without silently dropping events'), true);
+            this.queue.push({ value, bytes });
+            this.queuedBytes += bytes;
+            this.deliver();
+        }
+        if (Buffer.byteLength(this.buffer) > this.maxMessageBytes)
+            this.fail(new HerdrError('herdr_response_too_large', 'Herdr message exceeded maxResponseBytes'), true);
+    }
+    read() {
+        if (this.reader)
+            return Promise.reject(new Error('Only one reader may consume a Herdr connection'));
+        return new Promise((resolve, reject) => {
+            this.reader = { resolve, reject };
+            this.deliver();
+        });
+    }
+    write(data) {
+        if (this.ended)
+            return Promise.reject(this.error());
+        return new Promise((resolve, reject) => {
+            this.writes.add(reject);
+            this.socket.write(data, (error) => {
+                this.writes.delete(reject);
+                if (error) {
+                    this.fail(new HerdrError('herdr_unavailable', error.message));
+                    reject(this.error());
+                }
+                else if (this.failure)
+                    reject(this.failure);
+                else
+                    resolve();
+            });
+        });
+    }
+    async within(timeoutMs, action) {
+        validateTimeout(timeoutMs);
+        const timer = timeoutMs === null
+            ? undefined
+            : setTimeout(() => this.fail(new HerdrError('herdr_timeout', 'Herdr response timed out; delivery may be ambiguous'), true), timeoutMs);
+        try {
+            return await action();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async start(method, params, timeoutMs) {
+        return this.within(timeoutMs, async () => {
+            await this.write(JSON.stringify({ id: this.id, method, params }) + '\n');
+            const message = await this.read();
+            if (!message || message.id !== this.id || !Object.hasOwn(message, 'result'))
+                throw new HerdrError('herdr_invalid_response', `${method}: missing correlated result`);
+            return message.result;
+        });
+    }
+}
+export async function socketRequest(socketPath, method, params, options = {}) {
+    const timeoutMs = options.timeoutMs === undefined ? 10000 : options.timeoutMs;
+    validateTimeout(timeoutMs);
+    // Validate serialization before opening a connection.
+    JSON.stringify(params);
+    const connection = new JsonConnection(socketPath, options);
+    try {
+        return (await connection.start(method, params, timeoutMs));
+    }
+    finally {
+        connection.close();
+    }
+}

package/dist/mcp.js

@@ -21585,8 +21585,20 @@ var usageFields = external_exports.object({
   costUsd: external_exports.number().min(0).nullable().default(null)
 });
 
+// src/worktrees.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+
+// src/cleanup.ts
+var cleanupPolicySchema = external_exports.object({
+  autoRelease: external_exports.boolean().default(true),
+  collectAfterHours: external_exports.number().min(0).max(87600).nullable().default(null),
+  deleteMergedBranches: external_exports.boolean().default(false)
+}).strict();
+
 // src/version.ts
-var VERSION = "0.2.0";
+var VERSION = "0.2.2";
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -21621,7 +21633,9 @@ async function call(home2, action, input = {}) {
     method: "POST",
     headers: { "Content-Type": "application/json", Authorization: `Bearer ${c.token}` },
     body: JSON.stringify({ action, input }),
-    signal: AbortSignal.timeout(action === "profile.validate" ? 135e3 : 45e3)
+    signal: AbortSignal.timeout(
+      action.startsWith("cleanup.") ? 3e5 : action === "profile.validate" ? 135e3 : 45e3
+    )
   });
   const body = await response.json();
   if (!response.ok)
@@ -22021,4 +22035,70 @@ tool(
     disagreements: external_exports.array(external_exports.string())
   }
 );
+tool(
+  "cleanup_preview",
+  "cleanup.preview",
+  "Inspect release and collection eligibility, retained runs, delivery, archive and policy. Does not delete anything.",
+  { taskId: external_exports.string() },
+  true
+);
+tool(
+  "cleanup_configure",
+  "cleanup.configure",
+  "Authorize project cleanup policy. Automatic terminal release defaults on after integrated outcome completion; automatic worktree collection defaults off. Collection requires recorded delivery, sealed evidence and all consumers to finish.",
+  { lease: credentialsSchema, reason: external_exports.string(), policy: cleanupPolicySchema }
+);
+tool(
+  "cleanup_release",
+  "cleanup.release",
+  "After inspecting the result and confirming no further native continuation is needed, save diagnostics and close only the settled worker tab. Failed/cancelled files remain intact. No session or workspace closure.",
+  {
+    lease: credentialsSchema,
+    taskId: external_exports.string(),
+    runId: external_exports.string().optional(),
+    reason: external_exports.string()
+  }
+);
+tool(
+  "cleanup_reconcile",
+  "cleanup.reconcile",
+  "Reconcile uncertain tab closure using actual inspection. Closed requires the original tab to be absent; not-closed requires the original settled identity. Never replays closure.",
+  {
+    lease: credentialsSchema,
+    taskId: external_exports.string(),
+    runId: external_exports.string().optional(),
+    reason: external_exports.string(),
+    resolution: external_exports.enum(["closed", "not-closed"])
+  }
+);
+tool(
+  "cleanup_deliver",
+  "cleanup.deliver",
+  "Record merged, published, or explicitly abandoned work. This performs no commit, push, or merge. The checkout must be clean including ignored files. Merged/published needs an exact target ref containing its HEAD; published uses refreshed refs/remotes/... metadata.",
+  {
+    lease: credentialsSchema,
+    taskId: external_exports.string(),
+    reason: external_exports.string(),
+    disposition: external_exports.enum(["merged", "published", "abandoned"]),
+    targetRef: external_exports.string().optional()
+  }
+);
+tool(
+  "cleanup_archive",
+  "cleanup.archive",
+  "Seal all finished tasks sharing the managed checkout and preserve evidence, diagnostics and committed history. Release their terminals first. Sealed tasks cannot resume; use a new assignment for additional work.",
+  { lease: credentialsSchema, taskId: external_exports.string(), reason: external_exports.string() }
+);
+tool(
+  "cleanup_collect",
+  "cleanup.collect",
+  "Collect the exact archived worktree after rechecking consumers, delivery and integrity. Supply the preview archiveId. Optional branch deletion compares and deletes the exact archived tip after rechecking merged ancestry, or after explicit abandonment. No forced worktree removal, sessions, or workspace removal.",
+  {
+    lease: credentialsSchema,
+    taskId: external_exports.string(),
+    reason: external_exports.string(),
+    archiveId: external_exports.string(),
+    deleteBranch: external_exports.boolean().optional()
+  }
+);
 await server.connect(new StdioServerTransport());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theaileverage/marionette",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "engines": {
     "node": ">=22.13"
@@ -13,9 +13,12 @@
     "test": "node --import tsx --test tests/*.test.ts",
     "cli": "node --import tsx src/cli.ts",
     "mcp": "node --import tsx src/mcp.ts",
-    "format": "prettier --write src web tests scripts *.json *.ts *.md",
-    "format:check": "prettier --check src web tests scripts *.json *.ts *.md",
-    "prepack": "npm run check && npm test && npm run build"
+    "format": "prettier --write src web skills .github tests scripts *.json *.ts *.md",
+    "format:check": "prettier --check src web skills .github tests scripts *.json *.ts *.md",
+    "prepack": "npm run check && npm test && npm run build",
+    "release:prepare": "node scripts/release.mjs prepare",
+    "release:check": "node scripts/release.mjs check",
+    "sdk:generate": "node scripts/generate-herdr-sdk.mjs"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
@@ -47,9 +50,37 @@
     "ORCHESTRATION.md",
     "CHANGELOG.md",
     "DESIGN.md",
-    "VERIFICATION.md"
+    "VERIFICATION.md",
+    "LICENSE",
+    "CONTRIBUTING.md",
+    "RELEASING.md",
+    "dist/herdr-sdk.js",
+    "dist/herdr-sdk.d.ts",
+    "skills/",
+    "dist/herdr-protocol.js",
+    "dist/herdr-protocol.d.ts",
+    "dist/herdr-streams.js",
+    "dist/herdr-streams.d.ts",
+    "dist/herdr-transport.js",
+    "dist/herdr-transport.d.ts",
+    "vendor/herdr-0.9.0/LICENSE"
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theaileverage/marionette.git"
+  },
+  "homepage": "https://github.com/theaileverage/marionette#readme",
+  "bugs": {
+    "url": "https://github.com/theaileverage/marionette/issues"
+  },
+  "exports": {
+    "./herdr-sdk": {
+      "types": "./dist/herdr-sdk.d.ts",
+      "import": "./dist/herdr-sdk.js"
+    }
   }
 }