arc402-cli 0.9.18 → 0.10.0

package/dist/daemon/index.js

@@ -1,3 +1,42 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDaemon = runDaemon;
 /**
  * ARC-402 Daemon — main process entry point.
  *
@@ -7,22 +46,26 @@
  * IPC: Unix socket at ~/.arc402/daemon.sock (JSON-lines protocol).
  * Signals: SIGTERM → graceful shutdown.
  */
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-import * as net from "net";
-import * as http from "http";
-import { ethers } from "ethers";
-import Database from "better-sqlite3";
-import * as crypto from "crypto";
-import { loadDaemonConfig, loadMachineKey, DAEMON_DIR, DAEMON_PID, DAEMON_LOG, DAEMON_DB, DAEMON_SOCK, } from "./config.js";
-import { verifyWallet, getWalletBalance } from "./wallet-monitor.js";
-import { buildNotifier } from "./notify.js";
-import { HireListener } from "./hire-listener.js";
-import { UserOpsManager, buildAcceptCalldata } from "./userops.js";
-import { generateReceipt, extractLearnings, cleanJobDirectory } from "./job-lifecycle.js";
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const http = __importStar(require("http"));
+const ethers_1 = require("ethers");
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const crypto = __importStar(require("crypto"));
+const config_1 = require("./config");
+const compute_metering_1 = require("./compute-metering");
+const compute_session_1 = require("./compute-session");
+const wallet_monitor_1 = require("./wallet-monitor");
+const notify_1 = require("./notify");
+const hire_listener_1 = require("./hire-listener");
+const userops_1 = require("./userops");
+const job_lifecycle_1 = require("./job-lifecycle");
+const file_delivery_1 = require("./file-delivery");
+const delivery_client_1 = require("./delivery-client");
+const abis_1 = require("../abis");
 function openStateDB(dbPath) {
-    const db = new Database(dbPath);
+    const db = new better_sqlite3_1.default(dbPath);
     db.pragma("journal_mode = WAL");
     db.exec(`
     CREATE TABLE IF NOT EXISTS hire_requests (
@@ -77,6 +120,7 @@ function openStateDB(dbPath) {
       (@id, @agreement_id, @hirer_address, @capability, @price_eth, @deadline_unix, @spec_hash, @status, @created_at, @updated_at, @reject_reason)
   `);
     const getHireRequest = db.prepare(`SELECT * FROM hire_requests WHERE id = ?`);
+    const getHireRequestByAgreementId = db.prepare(`SELECT * FROM hire_requests WHERE agreement_id = ? ORDER BY created_at DESC LIMIT 1`);
     const updateStatus = db.prepare(`UPDATE hire_requests SET status = ?, reject_reason = ?, updated_at = ? WHERE id = ?`);
     const listPending = db.prepare(`SELECT * FROM hire_requests WHERE status = 'pending_approval' ORDER BY created_at ASC`);
     const listActive = db.prepare(`SELECT * FROM hire_requests WHERE status IN ('accepted', 'delivered') ORDER BY created_at ASC`);
@@ -89,6 +133,9 @@ function openStateDB(dbPath) {
         getHireRequest(id) {
             return getHireRequest.get(id);
         },
+        getHireRequestByAgreementId(agreementId) {
+            return getHireRequestByAgreementId.get(agreementId);
+        },
         updateHireRequestStatus(id, status, rejectReason) {
             updateStatus.run(status, rejectReason ?? null, Date.now(), id);
         },
@@ -108,7 +155,7 @@ function openStateDB(dbPath) {
     };
 }
 // ─── Auth token ───────────────────────────────────────────────────────────────
-const DAEMON_TOKEN_FILE = path.join(path.dirname(DAEMON_SOCK), "daemon.token");
+const DAEMON_TOKEN_FILE = path.join(path.dirname(config_1.DAEMON_SOCK), "daemon.token");
 function generateApiToken() {
     return crypto.randomBytes(32).toString("hex");
 }
@@ -126,7 +173,7 @@ function loadApiToken() {
 }
 const rateLimitMap = new Map();
 const RATE_LIMIT = 30;
-const RATE_WINDOW_MS = 60_000;
+const RATE_WINDOW_MS = 60000;
 function checkRateLimit(ip) {
     const now = Date.now();
     let bucket = rateLimitMap.get(ip);
@@ -160,8 +207,8 @@ function openLogger(logPath, foreground) {
 }
 function startIpcServer(ctx, log, apiToken) {
     // Remove stale socket
-    if (fs.existsSync(DAEMON_SOCK)) {
-        fs.unlinkSync(DAEMON_SOCK);
+    if (fs.existsSync(config_1.DAEMON_SOCK)) {
+        fs.unlinkSync(config_1.DAEMON_SOCK);
     }
     const server = net.createServer((socket) => {
         let buf = "";
@@ -200,9 +247,9 @@ function startIpcServer(ctx, log, apiToken) {
         });
         socket.on("error", () => { });
     });
-    server.listen(DAEMON_SOCK, () => {
-        fs.chmodSync(DAEMON_SOCK, 0o600);
-        log({ event: "ipc_ready", socket: DAEMON_SOCK });
+    server.listen(config_1.DAEMON_SOCK, () => {
+        fs.chmodSync(config_1.DAEMON_SOCK, 0o600);
+        log({ event: "ipc_ready", socket: config_1.DAEMON_SOCK });
     });
     return server;
 }
@@ -259,7 +306,7 @@ function handleIpcCommand(cmd, ctx, log) {
             log({ event: "hire_approved", id: cmd.id });
             // Trigger accept UserOp (fire and forget)
             if (ctx.userOps && ctx.config.serviceAgreementAddress) {
-                const callData = buildAcceptCalldata(ctx.config.serviceAgreementAddress, hire.agreement_id ?? cmd.id, ctx.walletAddress);
+                const callData = (0, userops_1.buildAcceptCalldata)(ctx.config.serviceAgreementAddress, hire.agreement_id ?? cmd.id, ctx.walletAddress);
                 ctx.userOps.submit(callData, ctx.walletAddress).then((hash) => {
                     log({ event: "userop_submitted", id: cmd.id, hash });
                 }).catch((err) => {
@@ -293,7 +340,7 @@ function handleIpcCommand(cmd, ctx, log) {
             const now = new Date().toISOString();
             const startedAt = new Date(hire.created_at).toISOString();
             // Generate execution receipt
-            const receipt = generateReceipt({
+            const receipt = (0, job_lifecycle_1.generateReceipt)({
                 agreementId: hire.agreement_id ?? cmd.id,
                 deliverableHash: hire.spec_hash ?? "0x0",
                 walletAddress: ctx.walletAddress,
@@ -302,7 +349,7 @@ function handleIpcCommand(cmd, ctx, log) {
             });
             log({ event: "receipt_generated", id: cmd.id, receipt_hash: receipt.receipt_hash });
             // Extract learnings
-            extractLearnings({
+            (0, job_lifecycle_1.extractLearnings)({
                 agreementId: hire.agreement_id ?? cmd.id,
                 taskDescription: hire.capability ?? "unknown",
                 deliverableHash: hire.spec_hash ?? "0x0",
@@ -315,7 +362,7 @@ function handleIpcCommand(cmd, ctx, log) {
             // Update status to complete
             ctx.db.updateHireRequestStatus(cmd.id, "complete");
             // Clean job directory (keep receipt + memory)
-            cleanJobDirectory(hire.agreement_id ?? cmd.id);
+            (0, job_lifecycle_1.cleanJobDirectory)(hire.agreement_id ?? cmd.id);
             return {
                 ok: true,
                 data: {
@@ -339,15 +386,15 @@ function formatUptime(seconds) {
         return `${m}m ${s}s`;
     return `${s}s`;
 }
-export async function runDaemon(foreground = false) {
-    fs.mkdirSync(DAEMON_DIR, { recursive: true, mode: 0o700 });
-    const log = openLogger(DAEMON_LOG, foreground);
+async function runDaemon(foreground = false) {
+    fs.mkdirSync(config_1.DAEMON_DIR, { recursive: true, mode: 0o700 });
+    const log = openLogger(config_1.DAEMON_LOG, foreground);
     log({ event: "daemon_starting" });
     // ── Step 1: Load config ──────────────────────────────────────────────────
     let config;
     try {
-        config = loadDaemonConfig();
-        log({ event: "config_loaded", path: path.join(os.homedir(), ".arc402", "daemon.toml") });
+        config = (0, config_1.loadDaemonConfig)();
+        log({ event: "config_loaded", path: require("path").join(require("os").homedir(), ".arc402", "daemon.toml") });
     }
     catch (err) {
         process.stderr.write(`Config error: ${err}\n`);
@@ -357,7 +404,7 @@ export async function runDaemon(foreground = false) {
     let machineKeyAddress;
     let machinePrivateKey;
     try {
-        const mk = loadMachineKey(config);
+        const mk = (0, config_1.loadMachineKey)(config);
         machinePrivateKey = mk.privateKey;
         machineKeyAddress = mk.address;
         log({ event: "machine_key_loaded", address: machineKeyAddress });
@@ -367,7 +414,7 @@ export async function runDaemon(foreground = false) {
         process.exit(1);
     }
     // ── Step 3: Connect to RPC ───────────────────────────────────────────────
-    const provider = new ethers.JsonRpcProvider(config.network.rpc_url);
+    const provider = new ethers_1.ethers.JsonRpcProvider(config.network.rpc_url);
     try {
         const chainId = (await provider.getNetwork()).chainId;
         if (Number(chainId) !== config.network.chain_id) {
@@ -383,7 +430,7 @@ export async function runDaemon(foreground = false) {
     }
     // ── Step 4+5: Verify wallet ──────────────────────────────────────────────
     try {
-        const walletStatus = await verifyWallet(config, provider, machineKeyAddress);
+        const walletStatus = await (0, wallet_monitor_1.verifyWallet)(config, provider, machineKeyAddress);
         log({
             event: "wallet_verified",
             address: walletStatus.contractAddress,
@@ -397,7 +444,7 @@ export async function runDaemon(foreground = false) {
         process.exit(1);
     }
     // ── Step 6: Connect bundler ──────────────────────────────────────────────
-    const userOps = new UserOpsManager(config, provider);
+    const userOps = new userops_1.UserOpsManager(config, provider);
     const bundlerOk = await userOps.pingBundler();
     if (!bundlerOk) {
         log({ event: "bundler_warn", msg: "Bundler endpoint unreachable — will retry on demand" });
@@ -407,17 +454,44 @@ export async function runDaemon(foreground = false) {
     // ── Step 7: Open state DB ────────────────────────────────────────────────
     let db;
     try {
-        db = openStateDB(DAEMON_DB);
-        log({ event: "state_db_opened", path: DAEMON_DB });
+        db = openStateDB(config_1.DAEMON_DB);
+        log({ event: "state_db_opened", path: config_1.DAEMON_DB });
     }
     catch (err) {
         process.stderr.write(`State DB error: ${err}\n`);
         process.exit(1);
     }
     // ── Setup notifier ───────────────────────────────────────────────────────
-    const notifier = buildNotifier(config);
+    const notifier = (0, notify_1.buildNotifier)(config);
+    // ── File delivery subsystem ──────────────────────────────────────────────
+    const fileDelivery = new file_delivery_1.FileDeliveryManager({
+        maxFileSizeMb: config.delivery.max_file_size_mb,
+        maxJobSizeMb: config.delivery.max_job_size_mb,
+    });
+    fileDelivery.setPartyResolver((agreementId) => {
+        const row = db.getHireRequestByAgreementId(agreementId);
+        if (!row)
+            return null;
+        return {
+            hirerAddress: row.hirer_address,
+            providerAddress: config.wallet.contract_address,
+        };
+    });
+    const deliveryClient = new delivery_client_1.DeliveryClient({ autoDownload: config.delivery.auto_download });
+    deliveryClient.log = log;
+    log({ event: "file_delivery_ready", serve_files: config.delivery.serve_files, auto_download: config.delivery.auto_download });
+    // ── Compute rental subsystem ─────────────────────────────────────────────
+    let computeMetering = null;
+    let computeSessions = null;
+    // Machine key signer — used for on-chain compute contract calls
+    const machineKeySigner = new ethers_1.ethers.Wallet(machinePrivateKey, provider);
+    if (config.compute.enabled) {
+        computeMetering = new compute_metering_1.ComputeMetering(machinePrivateKey, config.network.chain_id, config.compute.compute_agreement_address || config.wallet.contract_address, config.compute.metering_interval_seconds, config.compute.report_interval_minutes, config.compute.compute_agreement_address ? provider : undefined);
+        computeSessions = new compute_session_1.ComputeSessionManager(computeMetering);
+        log({ event: "compute_enabled", gpu_spec: config.compute.gpu_spec, rate_wei: config.compute.rate_per_hour_wei });
+    }
     // ── Step 10: Start relay listener ───────────────────────────────────────
-    const hireListener = new HireListener(config, db, notifier, config.wallet.contract_address);
+    const hireListener = new hire_listener_1.HireListener(config, db, notifier, config.wallet.contract_address);
     const ipcCtx = {
         db,
         config,
@@ -436,7 +510,7 @@ export async function runDaemon(foreground = false) {
         if (!hire || !hire.agreement_id || !config.serviceAgreementAddress)
             return;
         try {
-            const callData = buildAcceptCalldata(config.serviceAgreementAddress, hire.agreement_id, config.wallet.contract_address);
+            const callData = (0, userops_1.buildAcceptCalldata)(config.serviceAgreementAddress, hire.agreement_id, config.wallet.contract_address);
             const hash = await userOps.submit(callData, config.wallet.contract_address);
             log({ event: "hire_auto_accepted", id: hireId, userop_hash: hash });
             if (config.notifications.notify_on_hire_accepted) {
@@ -466,7 +540,7 @@ export async function runDaemon(foreground = false) {
                 log({ event: "hire_timeout_rejected", id: req.id });
             }
         }
-    }, 30_000);
+    }, 30000);
     // Rate limit map cleanup — every 5 minutes (prevents unbounded growth)
     rateLimitCleanupInterval = setInterval(() => {
         const now = Date.now();
@@ -478,7 +552,7 @@ export async function runDaemon(foreground = false) {
     // Balance monitor — every 5 minutes
     const balanceInterval = setInterval(async () => {
         try {
-            const balance = await getWalletBalance(config.wallet.contract_address, provider);
+            const balance = await (0, wallet_monitor_1.getWalletBalance)(config.wallet.contract_address, provider);
             const threshold = parseFloat(config.notifications.low_balance_threshold_eth);
             if (parseFloat(balance) < threshold) {
                 log({ event: "low_balance", balance_eth: balance, threshold_eth: config.notifications.low_balance_threshold_eth });
@@ -489,8 +563,8 @@ export async function runDaemon(foreground = false) {
     }, 5 * 60 * 1000);
     // ── Step 11: Write PID file (if not foreground) ──────────────────────────
     if (!foreground) {
-        fs.writeFileSync(DAEMON_PID, String(process.pid), { mode: 0o600 });
-        log({ event: "pid_written", pid: process.pid, path: DAEMON_PID });
+        fs.writeFileSync(config_1.DAEMON_PID, String(process.pid), { mode: 0o600 });
+        log({ event: "pid_written", pid: process.pid, path: config_1.DAEMON_PID });
     }
     // ── Generate and save API token ──────────────────────────────────────────
     const apiToken = generateApiToken();
@@ -510,7 +584,7 @@ export async function runDaemon(foreground = false) {
             return;
         const claimedSigner = req.headers["x-arc402-signer"];
         try {
-            const recovered = ethers.verifyMessage(body, sig);
+            const recovered = ethers_1.ethers.verifyMessage(body, sig);
             if (claimedSigner && recovered.toLowerCase() !== claimedSigner.toLowerCase()) {
                 log({ event: "sig_mismatch", claimed: claimedSigner, recovered });
             }
@@ -577,8 +651,9 @@ export async function runDaemon(foreground = false) {
             res.end(JSON.stringify({ error: "too_many_requests" }));
             return;
         }
-        // Auth required on all POST endpoints (GET public paths are open)
-        if (req.method === "POST" || (req.method === "GET" && !PUBLIC_GET_PATHS.has(pathname))) {
+        // Auth required on all POST endpoints (GET public paths are open).
+        // /job/* GET routes use party auth (verifyPartyAccess) instead of daemon bearer token.
+        if (req.method === "POST" || (req.method === "GET" && !PUBLIC_GET_PATHS.has(pathname) && !pathname.startsWith("/job/"))) {
             const authHeader = req.headers["authorization"] ?? "";
             const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : "";
             if (token !== apiToken) {
@@ -643,7 +718,7 @@ export async function runDaemon(foreground = false) {
                     return;
                 }
                 // Policy check
-                const { evaluatePolicy } = await import("./hire-listener.js");
+                const { evaluatePolicy } = await Promise.resolve().then(() => __importStar(require("./hire-listener")));
                 const activeCount = db.countActiveHireRequests();
                 const policyResult = evaluatePolicy(proposal, config, activeCount);
                 if (!policyResult.allowed) {
@@ -761,8 +836,9 @@ export async function runDaemon(foreground = false) {
                 const msg = JSON.parse(body);
                 const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
                 const deliverableHash = String(msg.deliverableHash ?? msg.deliverable_hash ?? "");
+                const filesUrl = String(msg.files_url ?? msg.filesUrl ?? "");
                 const from = String(msg.from ?? "");
-                log({ event: "delivery_received", agreementId, deliverableHash, from });
+                log({ event: "delivery_received", agreementId, deliverableHash, from, has_files_url: !!filesUrl });
                 // Update DB: mark delivered
                 const active = db.listActiveHireRequests();
                 const found = active.find(r => r.agreement_id === agreementId);
@@ -771,6 +847,15 @@ export async function runDaemon(foreground = false) {
                 if (config.notifications.notify_on_delivery) {
                     await notifier.notifyDelivery(agreementId, deliverableHash, "");
                 }
+                // Auto-download and verify if files_url provided and auto_download enabled
+                if (filesUrl && config.delivery.auto_download) {
+                    void deliveryClient.handleDeliveryNotification({ agreementId, deliverableHash, filesUrl })
+                        .then(result => {
+                        if (result)
+                            log({ event: "delivery_auto_downloaded", agreementId, ok: result.ok, root_hash_match: result.rootHashMatch, files: result.fileResults.length });
+                    })
+                        .catch(err => log({ event: "delivery_download_error", agreementId, error: String(err) }));
+                }
                 res.writeHead(200, { "Content-Type": "application/json" });
                 res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
             }
@@ -895,11 +980,399 @@ export async function runDaemon(foreground = false) {
             if (statusAuthed) {
                 statusPayload.active_agreements = db.listActiveHireRequests().length;
                 statusPayload.pending_approval = db.listPendingHireRequests().length;
+                if (config.delivery.serve_files) {
+                    const deliveriesDir = path.join(config_1.DAEMON_DIR, "deliveries");
+                    let totalDeliveries = 0, totalFiles = 0;
+                    if (fs.existsSync(deliveriesDir)) {
+                        const entries = fs.readdirSync(deliveriesDir);
+                        totalDeliveries = entries.length;
+                        for (const entry of entries) {
+                            const entryPath = path.join(deliveriesDir, entry);
+                            if (fs.statSync(entryPath).isDirectory()) {
+                                totalFiles += fs.readdirSync(entryPath).filter(f => f !== "_manifest.json").length;
+                            }
+                        }
+                    }
+                    statusPayload.file_delivery = { total_deliveries: totalDeliveries, total_files: totalFiles };
+                }
             }
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify(statusPayload));
             return;
         }
+        // ── Compute rental routes ─────────────────────────────────────────────
+        // POST /compute/propose — client proposes a compute session
+        if (pathname === "/compute/propose" && req.method === "POST") {
+            const body = await readBody(req, res);
+            if (body === null)
+                return;
+            try {
+                const msg = JSON.parse(body);
+                if (!computeSessions) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "compute_disabled" }));
+                    return;
+                }
+                const proposal = {
+                    sessionId: String(msg.sessionId ?? ""),
+                    clientAddress: String(msg.clientAddress ?? msg.client ?? ""),
+                    providerAddress: config.wallet.contract_address,
+                    ratePerHourWei: config.compute.rate_per_hour_wei,
+                    maxHours: Number(msg.maxHours ?? 1),
+                    gpuSpecHash: String(msg.gpuSpecHash ?? "0x0000000000000000000000000000000000000000000000000000000000000000"),
+                    workloadDescription: String(msg.workloadDescription ?? ""),
+                    depositAmount: String(msg.depositAmount ?? "0"),
+                    proposedAt: Math.floor(Date.now() / 1000),
+                };
+                if (!proposal.sessionId) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "sessionId required" }));
+                    return;
+                }
+                // Check capacity
+                const activeSessions = computeSessions.countByStatus("active");
+                if (activeSessions >= config.compute.max_concurrent_sessions) {
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ status: "rejected", reason: "at_capacity" }));
+                    return;
+                }
+                const result = computeSessions.handleProposal(proposal);
+                if (!result.ok) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: result.error }));
+                    return;
+                }
+                log({ event: "compute_proposed", sessionId: proposal.sessionId, client: proposal.clientAddress });
+                // Auto-accept if configured
+                if (config.compute.auto_accept_compute) {
+                    computeSessions.acceptSession(proposal.sessionId);
+                    log({ event: "compute_auto_accepted", sessionId: proposal.sessionId });
+                    // Wire to on-chain: provider calls acceptSession
+                    if (config.compute.compute_agreement_address) {
+                        try {
+                            const caContract = new ethers_1.ethers.Contract(config.compute.compute_agreement_address, abis_1.COMPUTE_AGREEMENT_ABI, machineKeySigner);
+                            const tx = await caContract.acceptSession(proposal.sessionId);
+                            await tx.wait();
+                            log({ event: "compute_accept_onchain", sessionId: proposal.sessionId, txHash: tx.hash });
+                        }
+                        catch (onchainErr) {
+                            log({ event: "compute_accept_onchain_error", sessionId: proposal.sessionId, error: String(onchainErr) });
+                        }
+                    }
+                }
+                const status = config.compute.auto_accept_compute ? "accepted" : "proposed";
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status, sessionId: proposal.sessionId }));
+            }
+            catch (err) {
+                log({ event: "compute_propose_error", error: String(err) });
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "invalid_request" }));
+            }
+            return;
+        }
+        // POST /compute/accept — provider accepts a proposed session
+        if (pathname === "/compute/accept" && req.method === "POST") {
+            const body = await readBody(req, res);
+            if (body === null)
+                return;
+            try {
+                const msg = JSON.parse(body);
+                const sessionId = String(msg.sessionId ?? "");
+                if (!computeSessions) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "compute_disabled" }));
+                    return;
+                }
+                const result = computeSessions.acceptSession(sessionId);
+                if (!result.ok) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: result.error }));
+                    return;
+                }
+                log({ event: "compute_accepted", sessionId });
+                // Wire to on-chain: provider calls acceptSession
+                if (config.compute.compute_agreement_address) {
+                    try {
+                        const caContract = new ethers_1.ethers.Contract(config.compute.compute_agreement_address, abis_1.COMPUTE_AGREEMENT_ABI, machineKeySigner);
+                        const tx = await caContract.acceptSession(sessionId);
+                        await tx.wait();
+                        log({ event: "compute_accept_onchain", sessionId, txHash: tx.hash });
+                    }
+                    catch (onchainErr) {
+                        log({ event: "compute_accept_onchain_error", sessionId, error: String(onchainErr) });
+                    }
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "accepted", sessionId }));
+            }
+            catch (err) {
+                log({ event: "compute_accept_error", error: String(err) });
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "invalid_request" }));
+            }
+            return;
+        }
+        // POST /compute/started — provider marks session as started
+        if (pathname === "/compute/started" && req.method === "POST") {
+            const body = await readBody(req, res);
+            if (body === null)
+                return;
+            try {
+                const msg = JSON.parse(body);
+                const sessionId = String(msg.sessionId ?? "");
+                const accessEndpoint = msg.accessEndpoint ? String(msg.accessEndpoint) : undefined;
+                if (!computeSessions) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "compute_disabled" }));
+                    return;
+                }
+                const result = computeSessions.startSession(sessionId, accessEndpoint);
+                if (!result.ok) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: result.error }));
+                    return;
+                }
+                log({ event: "compute_started", sessionId });
+                // Wire to on-chain: provider calls startSession
+                if (config.compute.compute_agreement_address) {
+                    try {
+                        const caContract = new ethers_1.ethers.Contract(config.compute.compute_agreement_address, abis_1.COMPUTE_AGREEMENT_ABI, machineKeySigner);
+                        const tx = await caContract.startSession(sessionId);
+                        await tx.wait();
+                        log({ event: "compute_start_onchain", sessionId, txHash: tx.hash });
+                    }
+                    catch (onchainErr) {
+                        log({ event: "compute_start_onchain_error", sessionId, error: String(onchainErr) });
+                    }
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "active", sessionId }));
+            }
+            catch (err) {
+                log({ event: "compute_started_error", error: String(err) });
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "invalid_request" }));
+            }
+            return;
+        }
+        // POST /compute/metrics — get current metrics (polling endpoint)
+        if (pathname === "/compute/metrics" && req.method === "POST") {
+            const body = await readBody(req, res);
+            if (body === null)
+                return;
+            try {
+                const msg = JSON.parse(body);
+                const sessionId = String(msg.sessionId ?? "");
+                if (!computeMetering || !computeSessions) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "compute_disabled" }));
+                    return;
+                }
+                const session = computeSessions.getSession(sessionId);
+                if (!session) {
+                    res.writeHead(404, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "session_not_found" }));
+                    return;
+                }
+                const current = computeMetering.getCurrentMetrics(sessionId);
+                const reports = computeMetering.getUsageReports(sessionId);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ sessionId, current, reports, consumedMinutes: session.consumedMinutes }));
+            }
+            catch (err) {
+                log({ event: "compute_metrics_error", error: String(err) });
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "invalid_request" }));
+            }
+            return;
+        }
+        // POST /compute/end — either party ends the session
+        if (pathname === "/compute/end" && req.method === "POST") {
+            const body = await readBody(req, res);
+            if (body === null)
+                return;
+            try {
+                const msg = JSON.parse(body);
+                const sessionId = String(msg.sessionId ?? "");
+                if (!computeSessions) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "compute_disabled" }));
+                    return;
+                }
+                const endResult = await computeSessions.endSession(sessionId);
+                if (!endResult.ok) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: endResult.error }));
+                    return;
+                }
+                const r = endResult.result;
+                log({
+                    event: "compute_ended",
+                    sessionId,
+                    consumedMinutes: r.consumedMinutes,
+                    costWei: r.costWei.toString(),
+                    refundWei: r.refundWei.toString(),
+                });
+                // Wire to on-chain: call endSession
+                if (config.compute.compute_agreement_address) {
+                    try {
+                        const caContract = new ethers_1.ethers.Contract(config.compute.compute_agreement_address, abis_1.COMPUTE_AGREEMENT_ABI, machineKeySigner);
+                        const tx = await caContract.endSession(sessionId);
+                        await tx.wait();
+                        log({ event: "compute_end_onchain", sessionId, txHash: tx.hash });
+                    }
+                    catch (onchainErr) {
+                        log({ event: "compute_end_onchain_error", sessionId, error: String(onchainErr) });
+                    }
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({
+                    status: "completed",
+                    sessionId,
+                    consumedMinutes: r.consumedMinutes,
+                    costWei: r.costWei.toString(),
+                    refundWei: r.refundWei.toString(),
+                    reports: r.reports,
+                }));
+            }
+            catch (err) {
+                log({ event: "compute_end_error", error: String(err) });
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "invalid_request" }));
+            }
+            return;
+        }
+        // POST /compute/dispute — client disputes a session
+        if (pathname === "/compute/dispute" && req.method === "POST") {
+            const body = await readBody(req, res);
+            if (body === null)
+                return;
+            try {
+                const msg = JSON.parse(body);
+                const sessionId = String(msg.sessionId ?? "");
+                if (!computeSessions) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "compute_disabled" }));
+                    return;
+                }
+                const result = computeSessions.disputeSession(sessionId);
+                if (!result.ok) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: result.error }));
+                    return;
+                }
+                log({ event: "compute_disputed", sessionId });
+                if (config.notifications.notify_on_dispute) {
+                    await notifier.notifyDispute(sessionId, String(msg.from ?? "client"));
+                }
+                // Wire to on-chain: call disputeSession
+                if (config.compute.compute_agreement_address) {
+                    try {
+                        const caContract = new ethers_1.ethers.Contract(config.compute.compute_agreement_address, abis_1.COMPUTE_AGREEMENT_ABI, machineKeySigner);
+                        const tx = await caContract.disputeSession(sessionId);
+                        await tx.wait();
+                        log({ event: "compute_dispute_onchain", sessionId, txHash: tx.hash });
+                    }
+                    catch (onchainErr) {
+                        log({ event: "compute_dispute_onchain_error", sessionId, error: String(onchainErr) });
+                    }
+                }
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "disputed", sessionId }));
+            }
+            catch (err) {
+                log({ event: "compute_dispute_error", error: String(err) });
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "invalid_request" }));
+            }
+            return;
+        }
+        // GET /compute/session/:id — session details
+        if (pathname.startsWith("/compute/session/") && req.method === "GET") {
+            const sessionId = pathname.slice("/compute/session/".length);
+            if (!computeSessions) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "compute_disabled" }));
+                return;
+            }
+            const session = computeSessions.getSession(sessionId);
+            if (!session) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "session_not_found" }));
+                return;
+            }
+            const current = computeMetering ? computeMetering.getCurrentMetrics(sessionId) : null;
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ session, current }));
+            return;
+        }
+        // GET /compute/sessions — list all sessions
+        if (pathname === "/compute/sessions" && req.method === "GET") {
+            if (!computeSessions) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "compute_disabled" }));
+                return;
+            }
+            const sessions = computeSessions.listSessions();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ sessions, count: sessions.length }));
+            return;
+        }
+        // ── File delivery routes ──────────────────────────────────────────────
+        // POST /job/:id/upload — store a file (daemon auth required via global gate above)
+        if (pathname.startsWith("/job/") && req.method === "POST") {
+            const parts = pathname.split("/");
+            // /job/<id>/upload → ["", "job", "<id>", "upload"]
+            if (parts.length === 4 && parts[3] === "upload") {
+                const agreementId = parts[2];
+                if (!config.delivery.serve_files) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "file_delivery_disabled" }));
+                    return;
+                }
+                await fileDelivery.handleUpload(req, res, agreementId, log);
+                return;
+            }
+        }
+        // GET /job/:id/files, GET /job/:id/files/:name, GET /job/:id/manifest — party-gated
+        if (pathname.startsWith("/job/") && req.method === "GET") {
+            const parts = pathname.split("/");
+            // /job/<id>/files/<name> → ["", "job", "<id>", "files", "<name>"]
+            if (parts.length === 5 && parts[3] === "files") {
+                const agreementId = parts[2];
+                const filename = decodeURIComponent(parts[4]);
+                if (!config.delivery.serve_files) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "file_delivery_disabled" }));
+                    return;
+                }
+                fileDelivery.handleDownloadFile(req, res, agreementId, filename, apiToken, log);
+                return;
+            }
+            // /job/<id>/files → ["", "job", "<id>", "files"]
+            if (parts.length === 4 && parts[3] === "files") {
+                const agreementId = parts[2];
+                if (!config.delivery.serve_files) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "file_delivery_disabled" }));
+                    return;
+                }
+                fileDelivery.handleListFiles(req, res, agreementId, apiToken, log);
+                return;
+            }
+            // /job/<id>/manifest → ["", "job", "<id>", "manifest"]
+            if (parts.length === 4 && parts[3] === "manifest") {
+                const agreementId = parts[2];
+                if (!config.delivery.serve_files) {
+                    res.writeHead(503, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "file_delivery_disabled" }));
+                    return;
+                }
+                fileDelivery.handleManifest(req, res, agreementId, apiToken, log);
+                return;
+            }
+        }
         // 404
         res.writeHead(404, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: "not_found" }));
@@ -934,13 +1407,13 @@ export async function runDaemon(foreground = false) {
         // Close HTTP + IPC
         httpServer.close();
         ipcServer.close();
-        if (fs.existsSync(DAEMON_SOCK))
-            fs.unlinkSync(DAEMON_SOCK);
+        if (fs.existsSync(config_1.DAEMON_SOCK))
+            fs.unlinkSync(config_1.DAEMON_SOCK);
         await notifier.notifyStopped();
         log({ event: "daemon_stopped" });
         // Clean up PID file
-        if (!foreground && fs.existsSync(DAEMON_PID)) {
-            fs.unlinkSync(DAEMON_PID);
+        if (!foreground && fs.existsSync(config_1.DAEMON_PID)) {
+            fs.unlinkSync(config_1.DAEMON_PID);
         }
         db.close();
         process.exit(0);