@xopcai/xopc 0.0.161 → 0.0.162

package/dist/src/browser/recipes/repository.js

@@ -0,0 +1,81 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+//#region src/browser/recipes/repository.ts
+const RECIPE_SELECT = `SELECT recipe_id, revision, name, description, status, yaml_source, risk_level, domains_json, created_at_ms, updated_at_ms FROM browser_recipes`;
+const RUN_SELECT = `SELECT run_id, recipe_id, recipe_revision, recipe_yaml, status, args_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms FROM browser_recipe_runs`;
+function recipeFromRow(row) {
+	return {
+		id: row.recipe_id,
+		revision: row.revision,
+		name: row.name,
+		description: row.description ?? void 0,
+		status: row.status,
+		yaml: row.yaml_source,
+		risk: row.risk_level,
+		domains: JSON.parse(row.domains_json),
+		createdAtMs: row.created_at_ms,
+		updatedAtMs: row.updated_at_ms
+	};
+}
+function runFromRow(row) {
+	return {
+		id: row.run_id,
+		recipeId: row.recipe_id,
+		recipeRevision: row.recipe_revision,
+		recipeYaml: row.recipe_yaml,
+		status: row.status,
+		args: JSON.parse(row.args_json),
+		result: row.result_json ? JSON.parse(row.result_json) : void 0,
+		error: row.error ?? void 0,
+		createdAtMs: row.created_at_ms,
+		startedAtMs: row.started_at_ms ?? void 0,
+		endedAtMs: row.ended_at_ms ?? void 0,
+		durationMs: row.duration_ms ?? void 0
+	};
+}
+function listBrowserRecipes() {
+	return getSqliteDatabase().prepare(`${RECIPE_SELECT} ORDER BY updated_at_ms DESC`).all().map(recipeFromRow);
+}
+function getBrowserRecipe(id) {
+	const row = getSqliteDatabase().prepare(`${RECIPE_SELECT} WHERE recipe_id = ?`).get(id);
+	return row ? recipeFromRow(row) : null;
+}
+function saveBrowserRecipe(recipe) {
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO browser_recipes (recipe_id, revision, name, description, status, yaml_source, risk_level, domains_json, created_at_ms, updated_at_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(recipe_id) DO UPDATE SET revision=excluded.revision, name=excluded.name, description=excluded.description, status=excluded.status, yaml_source=excluded.yaml_source, risk_level=excluded.risk_level, domains_json=excluded.domains_json, updated_at_ms=excluded.updated_at_ms`).run(recipe.id, recipe.revision, recipe.name, recipe.description ?? null, recipe.status, recipe.yaml, recipe.risk, JSON.stringify(recipe.domains), recipe.createdAtMs, recipe.updatedAtMs));
+}
+function deleteBrowserRecipe(id) {
+	return runSqliteWriteTransaction((db) => db.prepare("DELETE FROM browser_recipes WHERE recipe_id = ?").run(id).changes > 0);
+}
+function saveBrowserRecipeRun(run) {
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO browser_recipe_runs (run_id, recipe_id, recipe_revision, recipe_yaml, status, args_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(run_id) DO UPDATE SET status=excluded.status, result_json=excluded.result_json, error=excluded.error, started_at_ms=excluded.started_at_ms, ended_at_ms=excluded.ended_at_ms, duration_ms=excluded.duration_ms`).run(run.id, run.recipeId, run.recipeRevision, run.recipeYaml, run.status, JSON.stringify(run.args), run.result === void 0 ? null : JSON.stringify(run.result), run.error ?? null, run.createdAtMs, run.startedAtMs ?? null, run.endedAtMs ?? null, run.durationMs ?? null));
+}
+function getBrowserRecipeRun(id) {
+	const row = getSqliteDatabase().prepare(`${RUN_SELECT} WHERE run_id = ?`).get(id);
+	return row ? runFromRow(row) : null;
+}
+function listBrowserRecipeRuns(recipeId) {
+	return (recipeId ? getSqliteDatabase().prepare(`${RUN_SELECT} WHERE recipe_id = ? ORDER BY created_at_ms DESC LIMIT 100`).all(recipeId) : getSqliteDatabase().prepare(`${RUN_SELECT} ORDER BY created_at_ms DESC LIMIT 100`).all()).map(runFromRow);
+}
+function hasActiveBrowserRecipeRuns(recipeId) {
+	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM browser_recipe_runs WHERE recipe_id = ? AND status IN ('queued', 'running') LIMIT 1`).get(recipeId));
+}
+function listActiveBrowserRecipeRuns() {
+	return getSqliteDatabase().prepare(`${RUN_SELECT} WHERE status IN ('queued', 'running') ORDER BY created_at_ms ASC`).all().map(runFromRow);
+}
+function nextBrowserRecipeRunEventSeq(runId) {
+	return getSqliteDatabase().prepare("SELECT COALESCE(MAX(seq), 0) + 1 AS seq FROM browser_recipe_run_events WHERE run_id = ?").get(runId).seq;
+}
+function appendBrowserRecipeRunEvent(event) {
+	runSqliteWriteTransaction((db) => db.prepare("INSERT INTO browser_recipe_run_events (event_id, run_id, seq, type, data_json, created_at_ms) VALUES (?, ?, ?, ?, ?, ?)").run(event.id, event.runId, event.seq, event.type, event.data === void 0 ? null : JSON.stringify(event.data), event.createdAtMs));
+}
+function listBrowserRecipeRunEvents(runId) {
+	return getSqliteDatabase().prepare("SELECT event_id, run_id, seq, type, data_json, created_at_ms FROM browser_recipe_run_events WHERE run_id = ? ORDER BY seq ASC").all(runId).map((row) => ({
+		id: row.event_id,
+		runId: row.run_id,
+		seq: row.seq,
+		type: row.type,
+		data: row.data_json ? JSON.parse(row.data_json) : void 0,
+		createdAtMs: row.created_at_ms
+	}));
+}
+//#endregion
+export { appendBrowserRecipeRunEvent, deleteBrowserRecipe, getBrowserRecipe, getBrowserRecipeRun, hasActiveBrowserRecipeRuns, listActiveBrowserRecipeRuns, listBrowserRecipeRunEvents, listBrowserRecipeRuns, listBrowserRecipes, nextBrowserRecipeRunEventSeq, saveBrowserRecipe, saveBrowserRecipeRun };

package/dist/src/browser/recipes/runtime-service.d.ts

@@ -0,0 +1,6 @@
+import type { Config } from '../../config/schema.js';
+import { BrowserRecipeService } from './service.js';
+export declare function createRuntimeBrowserRecipeService(deps: {
+    getConfig: () => Config;
+    emit?: (type: string, payload: unknown) => void;
+}): BrowserRecipeService;

package/dist/src/browser/recipes/runtime-service.js

@@ -0,0 +1,30 @@
+import { BrowserManager } from "../manager.js";
+import { resolveBrowserBackendFromConfig } from "../backend-from-config.js";
+import { createBrowserActionRegistry } from "../actions/registry.js";
+import { runBrowserPipeline } from "../pipeline/runner.js";
+import { BrowserRecipeService } from "./service.js";
+//#region src/browser/recipes/runtime-service.ts
+function createRuntimeBrowserRecipeService(deps) {
+	const registry = createBrowserActionRegistry();
+	return new BrowserRecipeService(registry, async ({ yaml, args, signal, onStep }) => {
+		const manager = new BrowserManager({
+			getHeadless: () => false,
+			getBackend: () => resolveBrowserBackendFromConfig(deps.getConfig())
+		});
+		const taskId = `recipe-${Date.now()}`;
+		try {
+			await manager.ensureConnected();
+			return await runBrowserPipeline(yaml, args, {
+				page: manager.getExtensionProvider() ? null : await manager.getPage(taskId),
+				manager,
+				config: deps.getConfig(),
+				taskId,
+				signal
+			}, registry, { onStep });
+		} finally {
+			await manager.shutdown().catch(() => void 0);
+		}
+	}, deps.emit);
+}
+//#endregion
+export { createRuntimeBrowserRecipeService };

package/dist/src/browser/recipes/service.d.ts

@@ -0,0 +1,36 @@
+import { type BrowserRecipeStepEvent } from '../pipeline/runner.js';
+import type { BrowserActionRegistry, BrowserActionResult } from '../actions/types.js';
+import type { BrowserRecipe, BrowserRecipeRun, BrowserRecipeStatus } from './types.js';
+export type BrowserRecipeExecutor = (input: {
+    yaml: string;
+    args: Record<string, unknown>;
+    signal: AbortSignal;
+    onStep: (event: BrowserRecipeStepEvent) => void;
+}) => Promise<BrowserActionResult>;
+export declare class BrowserRecipeService {
+    private readonly registry;
+    private readonly executeRecipe;
+    private readonly emit?;
+    private activeRuns;
+    private executions;
+    private runWaiters;
+    constructor(registry: BrowserActionRegistry, executeRecipe: BrowserRecipeExecutor, emit?: (type: string, payload: unknown) => void);
+    list(): BrowserRecipe[];
+    get(id: string): BrowserRecipe;
+    listRuns(recipeId?: string): BrowserRecipeRun[];
+    getRun(id: string): BrowserRecipeRun;
+    listRunEvents(id: string): import("./types.js").BrowserRecipeRunEvent[];
+    validate(yaml: string): import("../pipeline/runner.js").ValidateResult;
+    save(input: {
+        yaml: string;
+        status?: BrowserRecipeStatus;
+        expectedId?: string;
+    }): BrowserRecipe;
+    remove(id: string): boolean;
+    startRun(recipeId: string, args: Record<string, unknown>): BrowserRecipeRun;
+    cancel(runId: string): boolean;
+    shutdown(): Promise<void>;
+    runAndWait(recipeId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<BrowserRecipeRun>;
+    private addEvent;
+    private execute;
+}

package/dist/src/browser/recipes/service.js

@@ -0,0 +1,186 @@
+import { validateBrowserPipeline } from "../pipeline/runner.js";
+import { appendBrowserRecipeRunEvent, deleteBrowserRecipe, getBrowserRecipe, getBrowserRecipeRun, hasActiveBrowserRecipeRuns, listActiveBrowserRecipeRuns, listBrowserRecipeRunEvents, listBrowserRecipeRuns, listBrowserRecipes, nextBrowserRecipeRunEventSeq, saveBrowserRecipe, saveBrowserRecipeRun } from "./repository.js";
+import { randomUUID } from "node:crypto";
+//#region src/browser/recipes/service.ts
+var BrowserRecipeService = class {
+	activeRuns = /* @__PURE__ */ new Map();
+	executions = /* @__PURE__ */ new Map();
+	runWaiters = /* @__PURE__ */ new Map();
+	constructor(registry, executeRecipe, emit) {
+		this.registry = registry;
+		this.executeRecipe = executeRecipe;
+		this.emit = emit;
+		for (const run of listActiveBrowserRecipeRuns()) {
+			const endedAtMs = Date.now();
+			const recovered = {
+				...run,
+				status: "failed",
+				error: "Gateway stopped before the run completed",
+				endedAtMs,
+				durationMs: run.startedAtMs ? endedAtMs - run.startedAtMs : void 0
+			};
+			saveBrowserRecipeRun(recovered);
+			this.addEvent(run.id, "run.completed", {
+				status: recovered.status,
+				error: recovered.error
+			});
+		}
+	}
+	list() {
+		return listBrowserRecipes();
+	}
+	get(id) {
+		return getBrowserRecipe(id);
+	}
+	listRuns(recipeId) {
+		return listBrowserRecipeRuns(recipeId);
+	}
+	getRun(id) {
+		return getBrowserRecipeRun(id);
+	}
+	listRunEvents(id) {
+		return listBrowserRecipeRunEvents(id);
+	}
+	validate(yaml) {
+		return validateBrowserPipeline(yaml, this.registry);
+	}
+	save(input) {
+		const validation = this.validate(input.yaml);
+		if (!validation.ok || !validation.document) throw new Error(validation.errors.map((error) => `${error.path}: ${error.message}`).join("\n"));
+		const document = validation.document;
+		if (input.expectedId && document.id !== input.expectedId) throw new Error("Recipe id cannot change");
+		const existing = getBrowserRecipe(document.id);
+		const now = Date.now();
+		const recipe = {
+			id: document.id,
+			revision: (existing?.revision ?? 0) + 1,
+			name: document.name,
+			description: document.description,
+			status: input.status ?? existing?.status ?? "published",
+			yaml: input.yaml,
+			risk: document.risk,
+			domains: document.domains,
+			createdAtMs: existing?.createdAtMs ?? now,
+			updatedAtMs: now
+		};
+		saveBrowserRecipe(recipe);
+		return recipe;
+	}
+	remove(id) {
+		if (hasActiveBrowserRecipeRuns(id)) throw new Error("Cannot delete a browser automation while it is running");
+		return deleteBrowserRecipe(id);
+	}
+	startRun(recipeId, args) {
+		const recipe = getBrowserRecipe(recipeId);
+		if (!recipe) throw new Error("Browser automation not found");
+		if (recipe.status !== "published") throw new Error("Only enabled browser automations can run");
+		if (!this.validate(recipe.yaml).ok) throw new Error("Browser automation is invalid");
+		const run = {
+			id: randomUUID(),
+			recipeId,
+			recipeRevision: recipe.revision,
+			recipeYaml: recipe.yaml,
+			status: "queued",
+			args,
+			createdAtMs: Date.now()
+		};
+		saveBrowserRecipeRun(run);
+		this.addEvent(run.id, "run.queued", { recipeId });
+		const execution = this.execute(run);
+		this.executions.set(run.id, execution);
+		execution.finally(() => this.executions.delete(run.id)).catch(() => void 0);
+		return run;
+	}
+	cancel(runId) {
+		const controller = this.activeRuns.get(runId);
+		if (!controller) return false;
+		controller.abort();
+		return true;
+	}
+	async shutdown() {
+		for (const controller of this.activeRuns.values()) controller.abort();
+		await Promise.allSettled(this.executions.values());
+	}
+	async runAndWait(recipeId, args, signal) {
+		const run = this.startRun(recipeId, args);
+		return new Promise((resolve) => {
+			const onAbort = () => this.cancel(run.id);
+			const complete = (completed) => {
+				signal?.removeEventListener("abort", onAbort);
+				const active = this.runWaiters.get(run.id);
+				active?.delete(complete);
+				if (active?.size === 0) this.runWaiters.delete(run.id);
+				resolve(completed);
+			};
+			const waiters = this.runWaiters.get(run.id) ?? /* @__PURE__ */ new Set();
+			waiters.add(complete);
+			this.runWaiters.set(run.id, waiters);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			if (signal?.aborted) onAbort();
+			const current = this.getRun(run.id);
+			if (current && current.status !== "queued" && current.status !== "running") complete(current);
+		});
+	}
+	addEvent(runId, type, data) {
+		const seq = nextBrowserRecipeRunEventSeq(runId);
+		const event = {
+			id: randomUUID(),
+			runId,
+			seq,
+			type,
+			data,
+			createdAtMs: Date.now()
+		};
+		appendBrowserRecipeRunEvent(event);
+		this.emit?.(`browser.recipe.${type}`, event);
+	}
+	async execute(run) {
+		const controller = new AbortController();
+		this.activeRuns.set(run.id, controller);
+		const startedAtMs = Date.now();
+		let current = {
+			...run,
+			status: "running",
+			startedAtMs
+		};
+		saveBrowserRecipeRun(current);
+		this.addEvent(run.id, "run.started");
+		try {
+			const result = await this.executeRecipe({
+				yaml: run.recipeYaml,
+				args: run.args,
+				signal: controller.signal,
+				onStep: (event) => this.addEvent(run.id, `step.${event.status}`, event)
+			});
+			const endedAtMs = Date.now();
+			current = {
+				...current,
+				status: controller.signal.aborted ? "cancelled" : result.ok ? "succeeded" : "failed",
+				result: result.data,
+				error: result.error?.message,
+				endedAtMs,
+				durationMs: endedAtMs - startedAtMs
+			};
+		} catch (error) {
+			const endedAtMs = Date.now();
+			current = {
+				...current,
+				status: controller.signal.aborted ? "cancelled" : "failed",
+				error: error instanceof Error ? error.message : String(error),
+				endedAtMs,
+				durationMs: endedAtMs - startedAtMs
+			};
+		} finally {
+			saveBrowserRecipeRun(current);
+			this.addEvent(run.id, "run.completed", {
+				status: current.status,
+				error: current.error
+			});
+			this.activeRuns.delete(run.id);
+			for (const resolve of this.runWaiters.get(run.id) ?? []) resolve(current);
+			this.runWaiters.delete(run.id);
+		}
+	}
+};
+//#endregion
+export { BrowserRecipeService };

package/dist/src/browser/recipes/types.d.ts

@@ -0,0 +1,36 @@
+export type BrowserRecipeStatus = 'published' | 'disabled';
+export type BrowserRecipeRunStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export interface BrowserRecipe {
+    id: string;
+    revision: number;
+    name: string;
+    description?: string;
+    status: BrowserRecipeStatus;
+    yaml: string;
+    risk: 'read_only' | 'account_write' | 'sensitive';
+    domains: string[];
+    createdAtMs: number;
+    updatedAtMs: number;
+}
+export interface BrowserRecipeRun {
+    id: string;
+    recipeId: string;
+    recipeRevision: number;
+    recipeYaml: string;
+    status: BrowserRecipeRunStatus;
+    args: Record<string, unknown>;
+    result?: unknown;
+    error?: string;
+    createdAtMs: number;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    durationMs?: number;
+}
+export interface BrowserRecipeRunEvent {
+    id: string;
+    runId: string;
+    seq: number;
+    type: string;
+    data?: unknown;
+    createdAtMs: number;
+}

package/dist/src/browser/recipes/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/cli/commands/browser-cli-helpers.js

@@ -3,9 +3,9 @@ import { loadPlaywrightCoreModule } from "../../browser/providers/playwright-doc
 import { BrowserManager } from "../../browser/manager.js";
 import { resolveBrowserBackendFromConfig } from "../../browser/backend-from-config.js";
 import { createBrowserActionRegistry } from "../../browser/actions/registry.js";
-import { loadBrowserPipelineSource } from "../../browser/pipeline/source.js";
-import { runBrowserPipeline, validateBrowserPipelineSource } from "../../browser/pipeline/runner.js";
+import { runBrowserPipeline, validateBrowserPipeline } from "../../browser/pipeline/runner.js";
 import "../../browser/index.js";
+import { readFile } from "node:fs/promises";
 //#region src/cli/commands/browser-cli-helpers.ts
 init_loader();
 let _manager = null;
@@ -57,11 +57,8 @@ async function executeBrowserCliAction(action, args) {
 }
 async function validatePipelineCli(file) {
 	let yamlSource;
-	let sourceLocation;
 	try {
-		const loaded = await loadBrowserPipelineSource(file);
-		yamlSource = loaded.source;
-		sourceLocation = loaded.location;
+		yamlSource = await readFile(file, "utf8");
 	} catch (e) {
 		const msg = e instanceof Error ? e.message : String(e);
 		console.error(`Failed to read pipeline source: ${msg}`);
@@ -69,7 +66,7 @@ async function validatePipelineCli(file) {
 		return;
 	}
 	const registry = createBrowserActionRegistry();
-	const result = await validateBrowserPipelineSource(yamlSource, registry, sourceLocation);
+	const result = validateBrowserPipeline(yamlSource, registry);
 	if (result.ok) console.log(`✓ Pipeline "${result.document.name}" is valid (${result.document.pipeline.length} steps).`);
 	else {
 		console.error("✗ Pipeline validation failed:");
@@ -79,11 +76,8 @@ async function validatePipelineCli(file) {
 }
 async function runPipelineCli(file, args) {
 	let yamlSource;
-	let sourceLocation;
 	try {
-		const loaded = await loadBrowserPipelineSource(file);
-		yamlSource = loaded.source;
-		sourceLocation = loaded.location;
+		yamlSource = await readFile(file, "utf8");
 	} catch (e) {
 		const msg = e instanceof Error ? e.message : String(e);
 		console.error(`Failed to read pipeline source: ${msg}`);
@@ -92,7 +86,7 @@ async function runPipelineCli(file, args) {
 	}
 	const registry = createBrowserActionRegistry();
 	const ctx = await getActionContext();
-	const result = await runBrowserPipeline(yamlSource, args, ctx, registry, { sourceLocation });
+	const result = await runBrowserPipeline(yamlSource, args, ctx, registry);
 	if (result.ok) {
 		if (result.text) console.log(result.text);
 		if (result.data && !result.text) console.log(JSON.stringify(result.data, null, 2));

package/dist/src/cli/commands/browser.js

@@ -38,16 +38,17 @@ function createBrowserCommand(_ctx) {
 			full_page: opts.fullPage
 		});
 	});
-	cmd.command("validate <file>").description("Validate a browser pipeline YAML file or URL without executing").action(async (file) => {
+	cmd.command("validate <file>").description("Validate a Browser Recipe v1 YAML file without executing").action(async (file) => {
 		const { validatePipelineCli } = await import("./browser-cli-helpers.js");
 		await validatePipelineCli(file);
 	});
-	cmd.command("run <file>").description("Run a browser pipeline YAML file or URL").option("--arg <args...>", "Pipeline args (key=value)").action(async (file, opts) => {
+	cmd.command("run <file>").description("Run a Browser Recipe v1 YAML file").option("--arg <args...>", "Recipe args (key=<JSON value>)").action(async (file, opts) => {
 		const { runPipelineCli } = await import("./browser-cli-helpers.js");
 		const args = {};
 		if (opts.arg) for (const a of opts.arg) {
 			const eq = a.indexOf("=");
-			if (eq > 0) args[a.slice(0, eq)] = a.slice(eq + 1);
+			if (eq <= 0) throw new Error(`Invalid --arg: ${a}`);
+			args[a.slice(0, eq)] = JSON.parse(a.slice(eq + 1));
 		}
 		await runPipelineCli(file, args);
 	});

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -52,7 +52,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v52).`,
+		message: `SQLite schema v${status.dbVersion} (current release v58).`,
 		hints: []
 	};
 }

package/dist/src/config/agent-profile.js

@@ -1,6 +1,6 @@
+import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import "../agent-manifest/index.js";
-import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir } from "../agent/agent-scope.js";
 import { init_session_key, parseSessionKey } from "../routing/session-key.js";
 import { agentExists, getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 //#region src/config/agent-profile.ts

package/dist/src/config/schema.d.ts

@@ -782,16 +782,16 @@ export declare const WorkspaceConfigSchema: z.ZodOptional<z.ZodObject<{
 }, z.core.$strip>>;
 export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
 export declare const GatewayBindModeSchema: z.ZodEnum<{
-    custom: "custom";
     auto: "auto";
+    custom: "custom";
     loopback: "loopback";
     lan: "lan";
     tailnet: "tailnet";
 }>;
 export declare const GatewayConfigSchema: z.ZodDefault<z.ZodObject<{
     bind: z.ZodOptional<z.ZodEnum<{
-        custom: "custom";
         auto: "auto";
+        custom: "custom";
         loopback: "loopback";
         lan: "lan";
         tailnet: "tailnet";
@@ -1951,8 +1951,8 @@ export declare const ConfigSchema: z.ZodDefault<z.ZodObject<{
     channels: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     gateway: z.ZodDefault<z.ZodObject<{
         bind: z.ZodOptional<z.ZodEnum<{
-            custom: "custom";
             auto: "auto";
+            custom: "custom";
             loopback: "loopback";
             lan: "lan";
             tailnet: "tailnet";

package/dist/src/config/schema.js

@@ -510,12 +510,12 @@ strict: z.boolean().optional() }).optional();
 			enabled: z.boolean().default(true),
 			/** Default TTL in ms (default 24h). */
 			defaultTtlMs: z.number().min(6e4).max(6048e5).default(864e5),
-			/** Maximum TTL in ms (default 7 days). */
-			maxTtlMs: z.number().min(6e4).max(2592e6).default(6048e5),
-			/** Maximum concurrent active shares (default 100). */
-			maxActiveShares: z.number().min(1).max(1e4).default(100),
-			/** Maximum shareable file size in bytes (default 100MB). */
-			maxFileSize: z.number().min(1048576).max(10737418240).default(104857600),
+			/** Maximum TTL in ms (default 30 days). */
+			maxTtlMs: z.number().min(6e4).max(2592e6).default(2592e6),
+			/** Maximum concurrent active shares (default 500). */
+			maxActiveShares: z.number().min(1).max(1e4).default(500),
+			/** Maximum shareable file size in bytes (default 500 MB). */
+			maxFileSize: z.number().min(1048576).max(10737418240).default(524288e3),
 			/** MIME types allowed for inline preview (?inline=1). */
 			inlinePreviewMimes: z.array(z.string()).default([
 				"image/png",
@@ -532,10 +532,10 @@ strict: z.boolean().optional() }).optional();
 			/** Folder-sharing controls (browse + ZIP). */
 			directory: z.object({
 				enabled: z.boolean().default(true),
-				/** Maximum folder size in bytes at scan time (default 1 GB). */
-				maxFolderSize: z.number().int().min(1048576).max(10737418240).default(1073741824),
+				/** Maximum folder size in bytes at scan time (default 2 GB). */
+				maxFolderSize: z.number().int().min(1048576).max(10737418240).default(2147483648),
 				/** Maximum number of entries scanned for a single folder share. */
-				maxFileCount: z.number().int().min(1).max(1e5).default(1e3),
+				maxFileCount: z.number().int().min(1).max(1e5).default(1e4),
 				/** Traversal depth cap (defense against recursive symlinks). */
 				maxDepth: z.number().int().min(1).max(64).default(20),
 				/** In-memory directory listing cache TTL. */
@@ -544,8 +544,8 @@ strict: z.boolean().optional() }).optional();
 				zipConcurrency: z.number().int().min(1).max(8).default(1)
 			}).default({
 				enabled: true,
-				maxFolderSize: 1073741824,
-				maxFileCount: 1e3,
+				maxFolderSize: 2147483648,
+				maxFileCount: 1e4,
 				maxDepth: 20,
 				listingCacheMs: 6e4,
 				zipConcurrency: 1
@@ -556,24 +556,24 @@ strict: z.boolean().optional() }).optional();
 			enabled: z.boolean().default(true),
 			/** Public host suffix that subdomain shares are served under. */
 			publicHostSuffix: z.string().min(1).default("share.xopc.ai"),
-			/** Default TTL in ms (default 6h, shorter than file shares — live app surface). */
-			defaultTtlMs: z.number().int().min(6e4).max(6048e5).default(216e5),
-			/** Maximum TTL in ms (default 7 days). */
-			maxTtlMs: z.number().int().min(6e4).max(2592e6).default(6048e5),
-			/** Maximum concurrent active site shares. */
-			maxActiveSites: z.number().int().min(1).max(1e3).default(5),
+			/** Default TTL in ms (default 24h). */
+			defaultTtlMs: z.number().int().min(6e4).max(6048e5).default(864e5),
+			/** Maximum TTL in ms (default 30 days). */
+			maxTtlMs: z.number().int().min(6e4).max(2592e6).default(2592e6),
+			/** Maximum concurrent active site shares (default 50). */
+			maxActiveSites: z.number().int().min(1).max(1e3).default(50),
 			static: z.object({
 				enabled: z.boolean().default(true),
 				/** Maximum total bytes of files served per static site. */
-				maxRootDirSize: z.number().int().min(1048576).max(10737418240).default(524288e3),
+				maxRootDirSize: z.number().int().min(1048576).max(10737418240).default(1073741824),
 				/** Maximum file count under root dir. */
-				maxFileCount: z.number().int().min(1).max(1e5).default(1e4),
+				maxFileCount: z.number().int().min(1).max(1e5).default(2e4),
 				/** Whether HTML/CSS rewrite of absolute paths is on by default. */
 				rewriteEnabledByDefault: z.boolean().default(false)
 			}).default({
 				enabled: true,
-				maxRootDirSize: 524288e3,
-				maxFileCount: 1e4,
+				maxRootDirSize: 1073741824,
+				maxFileCount: 2e4,
 				rewriteEnabledByDefault: false
 			}),
 			proxy: z.object({

package/dist/src/gateway/agents-admin.js

@@ -1,5 +1,5 @@
-import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
+import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
 import { WORKSPACE_FILES, init_paths, resolveUserProfilePath } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -209,7 +209,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
     /** Masked `cfg.providers` for capability keys (image / STT / etc.). */
     providersConfig: Record<string, import("./safe-providers-config.js").SafeProviderAuthEntry>;
     gateway: {
-        bind: "custom" | "auto" | "loopback" | "lan" | "tailnet";
+        bind: "auto" | "custom" | "loopback" | "lan" | "tailnet";
         customBindHost: string;
         port: number;
         corsOrigins: string[];

package/dist/src/gateway/hono/routes/browser-workflows.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerBrowserWorkflowRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;