quukk-clawmessenger 0.1.0-beta.21 → 0.1.0-beta.22

package/dist/go/binary.d.ts

@@ -1,6 +1,6 @@
 export type BridgeRuntimePackage = {
     packageName: string;
-    binary: 'multica.exe' | 'multica';
+    binary: 'clawmessenger-runtime.exe' | 'clawmessenger-runtime';
 };
 export type BridgeBinaryErrorCode = 'unsupported_platform' | 'runtime_package_missing' | 'package_version_mismatch' | 'manifest_too_large' | 'manifest_invalid' | 'manifest_version_mismatch' | 'binary_not_file' | 'binary_read_failed' | 'binary_hash_mismatch';
 export declare class BridgeBinaryError extends Error {

package/dist/go/binary.js

@@ -22,33 +22,33 @@ const ManifestSchema = z.strictObject({
     goVersion: z.string().regex(/^go1\.[1-9]\d*(?:\.(?:0|[1-9]\d*))?(?:[a-z]+\d*)?$/),
     sourceCommit: z.string().regex(/^[0-9a-f]{40}$/),
     sha256: z.string().regex(/^[0-9a-f]{64}$/),
-    binary: z.enum(['multica.exe', 'multica']),
+    binary: z.enum(['clawmessenger-runtime.exe', 'clawmessenger-runtime']),
     modules: z.array(z.string().regex(/^[^\s@]+@v[^\s@]+$/)).min(1).max(256),
 });
 const packageMatrix = {
     'win32/x64': {
         packageName: '@quukk/clawmessenger-runtime-win32-x64',
-        binary: 'multica.exe',
+        binary: 'clawmessenger-runtime.exe',
     },
     'win32/arm64': {
         packageName: '@quukk/clawmessenger-runtime-win32-arm64',
-        binary: 'multica.exe',
+        binary: 'clawmessenger-runtime.exe',
     },
     'darwin/x64': {
         packageName: '@quukk/clawmessenger-runtime-darwin-x64',
-        binary: 'multica',
+        binary: 'clawmessenger-runtime',
     },
     'darwin/arm64': {
         packageName: '@quukk/clawmessenger-runtime-darwin-arm64',
-        binary: 'multica',
+        binary: 'clawmessenger-runtime',
     },
     'linux/x64': {
         packageName: '@quukk/clawmessenger-runtime-linux-x64',
-        binary: 'multica',
+        binary: 'clawmessenger-runtime',
     },
     'linux/arm64': {
         packageName: '@quukk/clawmessenger-runtime-linux-arm64',
-        binary: 'multica',
+        binary: 'clawmessenger-runtime',
     },
 };
 async function readBoundedFile(path, maximumBytes) {

package/dist/go/recovering-task.d.ts

@@ -0,0 +1,24 @@
+import type { BridgeTaskEvent, BridgeTaskPort } from './types.js';
+export interface RecoveringBridgeTaskOptions {
+    resolveTask(): BridgeTaskPort;
+    ensureBridge(): Promise<void>;
+    refreshRuntime(runtimeId: string): Promise<boolean>;
+}
+export declare class RecoveringBridgeTask implements BridgeTaskPort {
+    #private;
+    constructor(options: RecoveringBridgeTaskOptions);
+    startTask(input: {
+        model?: string;
+        requestId?: string;
+        runtimeId: string;
+        conversationKey: string;
+        prompt: string;
+        workdir: string;
+        resumeSessionId?: string;
+    }): Promise<{
+        taskId: string;
+        eventsUrl: string;
+    }>;
+    events(taskId: string, afterEventId?: number): AsyncIterable<BridgeTaskEvent>;
+    cancelTask(taskId: string): Promise<void>;
+}

package/dist/go/recovering-task.js

@@ -0,0 +1,45 @@
+import { BridgeClientError } from './client.js';
+export class RecoveringBridgeTask {
+    #options;
+    constructor(options) {
+        this.#options = options;
+    }
+    async startTask(input) {
+        try {
+            return await this.#options.resolveTask().startTask(input);
+        }
+        catch (error) {
+            if (!(error instanceof BridgeClientError))
+                throw error;
+            if (error.code === 'transport_error') {
+                await this.#recover(error, () => this.#options.ensureBridge());
+                return this.#options.resolveTask().startTask(input);
+            }
+            if (error.code === 'request_timeout') {
+                await this.#recover(error, () => this.#options.ensureBridge());
+                throw error;
+            }
+            if (error.code === 'remote_error' && (error.status === 409 || error.status === 404)) {
+                const ready = await this.#recover(error, () => this.#options.refreshRuntime(input.runtimeId));
+                if (!ready)
+                    throw error;
+                return this.#options.resolveTask().startTask(input);
+            }
+            throw error;
+        }
+    }
+    async #recover(original, action) {
+        try {
+            return await action();
+        }
+        catch {
+            throw original;
+        }
+    }
+    events(taskId, afterEventId) {
+        return this.#options.resolveTask().events(taskId, afterEventId);
+    }
+    async cancelTask(taskId) {
+        await this.#options.resolveTask().cancelTask(taskId);
+    }
+}

package/dist/service.js

@@ -7,6 +7,7 @@ import { BindingService, } from './bindings/service.js';
 import { RUNTIME_ID_PATTERN, StoredConfigSchema, TOKEN_REF_PATTERN, } from './config/schema.js';
 import { localPaths } from './config/paths.js';
 import { LocalStore, authorizeWorkdir, } from './config/store.js';
+import { RecoveringBridgeTask } from './go/recovering-task.js';
 import { BridgeHealthSchema, BridgeRuntimeListSchema, } from './go/types.js';
 import { ActivityResponseSchema, BindingMutationResponseSchema, DiagnosticsResponseSchema, EnableResponseSchema, LocalRoutes, RuntimesResponseSchema, SettingsResponseSchema, ControlPairingResponseSchema, PairingResponseSchema, } from './http/routes.js';
 import { BrowserSessionStore, deriveControlCredential } from './http/security.js';
@@ -1651,8 +1652,20 @@ async function composeProductionServiceWithin(options, deadline) {
             },
         });
         const control = createConservativeRouterControl({ runtimes: client, bindings, workers, mutationGate });
+        let activeClient = client;
+        const recoveringTask = new RecoveringBridgeTask({
+            resolveTask: () => activeClient,
+            ensureBridge: async () => {
+                const running = await bridge.ensureStarted({});
+                activeClient = running.client;
+            },
+            refreshRuntime: async (runtimeId) => {
+                const runtimes = await activeClient.refreshRuntimes();
+                return runtimes.find(candidate => candidate.id === runtimeId)?.status === 'ready';
+            },
+        });
         router = factories.createRouter({
-            task: client,
+            task: recoveringTask,
             interactiveAvailable: async (identity) => {
                 const runtime = parseCatalog(await client.runtimes()).find(item => item.id === identity.runtimeId);
                 return runtime !== undefined && nodeCapabilitiesForRuntime(runtime).includes('discussion_interactive_rounds');

package/package.json

@@ -1,11 +1,25 @@
 {
   "name": "quukk-clawmessenger",
-  "version": "0.1.0-beta.21",
+  "version": "0.1.0-beta.22",
   "description": "Connect local AI agents to ClawMessenger, built on Multica",
   "type": "module",
-  "engines": { "node": ">=22.13.0" },
-  "bin": { "quukk-clawmessenger": "bin/quukk-clawmessenger.js" },
-  "files": ["bin", "dist", "scripts/audit-tarball.mjs", "scripts/postinstall.mjs", "LICENSE", "NOTICE", "MODIFICATIONS.md", "THIRD_PARTY_NOTICES.md", "README.md"],
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "bin": {
+    "quukk-clawmessenger": "bin/quukk-clawmessenger.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "scripts/audit-tarball.mjs",
+    "scripts/postinstall.mjs",
+    "LICENSE",
+    "NOTICE",
+    "MODIFICATIONS.md",
+    "THIRD_PARTY_NOTICES.md",
+    "README.md"
+  ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc --noEmit",

package/scripts/audit-tarball.mjs

@@ -101,6 +101,7 @@ const ENTRY_MODULES = [
   'config/store',
   'go/binary',
   'go/client',
+  'go/recovering-task',
   'go/sse',
   'go/types',
   'http/routes',