@alashi/cli 0.15.0 → 0.16.0

package/dist/{store-dipRcfKX.mjs → store-DvLX0Kft.mjs}

@@ -1,6 +1,6 @@
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { deleteCookie, getCookie, setCookie } from "hono/cookie";
-import { APP_NAME_PATTERN, AppSdkError, ConfigError, JsonFileStore, SDK_VERSION, evaluateAppConfig, interpolateConfig, manifestConfigDefaults, mergeConfig, parseAgentFile, parseManifestWithWarnings } from "@alashi/apps-sdk";
+import { APP_NAME_PATTERN, AppSdkError, ConfigError, JsonFileStore, SDK_VERSION, compilePolicy, describeRule, evaluateAppConfig, evaluatePolicy, interpolateConfig, manifestConfigDefaults, mergeConfig, parseAgentFile, parseManifestWithWarnings, permissionsPolicy } from "@alashi/apps-sdk";
 import semver from "semver";
 import { execFile } from "node:child_process";
 import { appendFile, cp, lstat, mkdir, readFile, readdir, readlink, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
@@ -1584,6 +1584,21 @@ function superviseSession(session, app, registry) {
 		...session.respondToApproval !== void 0 && { respondToApproval: session.respondToApproval.bind(session) }
 	};
 }
+/** Runs `onClose` once when the session closes (drops its gateway grants). */
+function endOnClose(session, onClose) {
+	return {
+		get id() {
+			return session.id;
+		},
+		send: (input) => session.send(input),
+		interrupt: () => session.interrupt(),
+		close: async () => {
+			onClose();
+			await session.close();
+		},
+		...session.respondToApproval !== void 0 && { respondToApproval: session.respondToApproval.bind(session) }
+	};
+}
 /**
 * Wraps the host provider so every session an app opens automatically gets
 * its manifest-declared MCP servers, tool allowlist, agents, skills,
@@ -1600,6 +1615,30 @@ function scopeProvider(provider, defaults) {
 				...defaults.mcpServers,
 				...options.mcpServers
 			};
+			if (defaults.gateSession) {
+				const { allowedTools: callAllowed, askTools: callAsk, ...rest } = options;
+				const gate = defaults.gateSession({
+					...callAllowed !== void 0 && { allowedTools: callAllowed },
+					...callAsk !== void 0 && { askTools: callAsk }
+				});
+				const agents = {
+					...defaults.agents,
+					...rest.agents
+				};
+				const skillDirs = [.../* @__PURE__ */ new Set([...defaults.skillDirs, ...rest.skillDirs ?? []])];
+				let session = await provider.createSession({
+					cwd: defaults.cwd,
+					...defaults.instructions !== void 0 && { systemPrompt: defaults.instructions },
+					...rest,
+					...Object.keys(mcpServers).length > 0 && { mcpServers },
+					toolGate: gate.gate,
+					...Object.keys(agents).length > 0 && { agents },
+					...skillDirs.length > 0 && { skillDirs }
+				});
+				session = endOnClose(session, gate.end);
+				if (defaults.supervise) session = defaults.supervise(session);
+				return defaults.recordUsage ? meterSession(session, defaults.recordUsage) : session;
+			}
 			const granted = (defaults.readGrants ? await defaults.readGrants() : []).filter((tool) => defaults.askTools.includes(tool));
 			const allowedTools = [.../* @__PURE__ */ new Set([
 				...defaults.allowedTools,
@@ -1717,7 +1756,7 @@ async function resolveAppConfig(store, manifest) {
 * `ctx.usage` answers "nothing recorded" — the member is required by the
 * contract, so it is always present.
 */
-async function buildAppContext(store, manifest, provider, usage, approvals) {
+async function buildAppContext(store, manifest, provider, usage, approvals, gateway) {
 	const name = manifest.name;
 	const dataDir = store.appDataDir(name);
 	const repoDir = store.appRepoDir(name);
@@ -1735,7 +1774,35 @@ async function buildAppContext(store, manifest, provider, usage, approvals) {
 	const allowedTools = manifest.permissions.allowedTools.filter((tool) => !excluded.some((server) => tool.startsWith(`mcp__${server}__`)));
 	const logger = createLogger(name);
 	let askTools = manifest.permissions.askTools.filter((tool) => !excluded.some((server) => tool.startsWith(`mcp__${server}__`)));
-	if (askTools.length > 0 && provider.supportsApprovals !== true) {
+	const agents = await loadAgents(repoDir, manifest.agents);
+	const gated = gateway !== void 0 && provider.supportsToolGate === true && provider.supportsApprovals === true;
+	const declaresPolicy = manifest.permissions.rules.length > 0 || manifest.permissions.default !== "deny";
+	let gateSession;
+	if (gated) {
+		const base = permissionsPolicy({
+			...manifest.permissions,
+			allowedTools,
+			askTools
+		});
+		const implicit = Object.keys(agents).length > 0 ? [{
+			id: "implicit.Agent",
+			tool: "Agent",
+			decision: "allow"
+		}] : [];
+		gateSession = (extra) => gateway.session(name, compilePolicy({
+			default: base.default,
+			rules: [
+				...base.rules,
+				...implicit,
+				...permissionsPolicy(extra).rules
+			]
+		}));
+	} else if (declaresPolicy) {
+		logger.warn(`AI engine "${provider.name}" cannot enforce policy rules; all tools are disabled for this app`);
+		allowedTools.length = 0;
+		askTools = [];
+	}
+	if (!gated && askTools.length > 0 && provider.supportsApprovals !== true) {
 		logger.warn(`AI engine "${provider.name}" does not support interactive approvals; ask-tier tools are disabled`, { askTools });
 		askTools = [];
 	}
@@ -1757,11 +1824,10 @@ async function buildAppContext(store, manifest, provider, usage, approvals) {
 			mcpServers,
 			allowedTools,
 			askTools,
-			...askTools.length > 0 && {
-				readGrants: async () => (await store.readGrants(name)).tools,
-				...approvals !== void 0 && { supervise: (session) => superviseSession(session, name, approvals) }
-			},
-			agents: await loadAgents(repoDir, manifest.agents),
+			...gateSession !== void 0 && { gateSession },
+			...(gated || askTools.length > 0) && approvals !== void 0 && { supervise: (session) => superviseSession(session, name, approvals) },
+			...!gated && askTools.length > 0 && { readGrants: async () => (await store.readGrants(name)).tools },
+			agents,
 			skillDirs: manifest.skills.map((dir) => resolve(repoDir, dir)),
 			...instructions !== void 0 && { instructions },
 			cwd: dataDir,
@@ -1814,7 +1880,9 @@ var ApprovalRegistry = class {
 			input: event.input,
 			requestedAt: new Date(now).toISOString(),
 			expiresAt: new Date(now + this.#timeoutMs).toISOString(),
-			status: "pending"
+			status: "pending",
+			...event.ruleId !== void 0 && { ruleId: event.ruleId },
+			...event.reason !== void 0 && { reason: event.reason }
 		};
 		const timer = setTimeout(() => this.#timeout(event.approvalId), this.#timeoutMs);
 		timer.unref?.();
@@ -2477,6 +2545,45 @@ function roCard(title, children) {
   ]);
 }
 
+// Every tool call passes the host's tool gateway: user overrides first
+// (never past a manifest deny), then the manifest's rules, then the default.
+function ruleRow(r) {
+  return el('div', { class: 'ro-item' }, [
+    el('span', { class: 'chip ' + (r.decision === 'allow' ? 'on' : r.decision === 'deny' ? 'off' : ''),
+                 text: r.decision }),
+    document.createTextNode(' '),
+    el('code', { text: r.summary }),
+    el('div', { class: 'desc', text: (r.description && r.description !== r.summary ? r.description + ' · ' : '') + 'id: ' + r.id }),
+  ]);
+}
+
+function policyCard(p) {
+  const body = [];
+  if (!p.gated) {
+    body.push(el('div', { class: 'desc', text: 'This AI engine cannot gate individual tool calls; only name-level allow/ask lists apply.' }));
+  }
+  if (p.user.length > 0) {
+    body.push(el('h3', { text: 'Your overrides' }), ...p.user.map(ruleRow));
+  }
+  body.push(el('h3', { text: 'Declared by the app' }));
+  body.push(...(p.manifest.length > 0 ? p.manifest.map(ruleRow) : [el('div', { class: 'desc', text: 'No rules.' })]));
+  body.push(el('div', { class: 'desc', text: 'Anything else: ' + p.default + '.' }));
+  return roCard('Tool policy', body);
+}
+
+function toolCallsCard(calls) {
+  return roCard('Recent tool calls', [usageTable(
+    ['When', 'Tool', 'Decision', 'Why', 'Input'],
+    calls.slice().reverse().map((c) => [
+      new Date(c.at).toLocaleString(),
+      c.tool,
+      c.decision + ' (' + c.source + ')',
+      c.reason,
+      c.inputPreview.length > 80 ? c.inputPreview.slice(0, 80) + '…' : c.inputPreview,
+    ]),
+  )]);
+}
+
 function renderManifest(m) {
   const root = document.getElementById('manifest-cards');
   root.replaceChildren();
@@ -2522,10 +2629,8 @@ function renderManifest(m) {
     ]))));
   }
 
-  if (m.allowedTools.length > 0) {
-    cards.push(roCard('Allowed tools', m.allowedTools.map((t) =>
-      el('div', {}, [el('code', { text: t })]))));
-  }
+  if (m.policy) cards.push(policyCard(m.policy));
+  if (m.toolCalls && m.toolCalls.length > 0) cards.push(toolCallsCard(m.toolCalls));
 
   if (m.jobs.length > 0) {
     cards.push(roCard('Jobs', m.jobs.map((j) => el('div', { class: 'ro-item' }, [
@@ -2559,7 +2664,16 @@ async function load() {
     return;
   }
   render(await res.json());
-  if (manRes.ok) renderManifest(await manRes.json());
+  if (manRes.ok) {
+    const m = await manRes.json();
+    const [policyRes, callsRes] = await Promise.all([
+      fetch('/api/apps/' + APP + '/policy'),
+      fetch('/api/apps/' + APP + '/tool-calls?limit=20'),
+    ]);
+    if (policyRes.ok) m.policy = await policyRes.json();
+    if (callsRes.ok) m.toolCalls = (await callsRes.json()).calls;
+    renderManifest(m);
+  }
 }
 
 document.getElementById('save').addEventListener('click', async () => {
@@ -2587,6 +2701,193 @@ load();
 `;
 }
 //#endregion
+//#region src/tool-gateway.ts
+const INPUT_PREVIEW_CHARS = 1e3;
+/** Calls the gate answered `ask` and nobody has decided yet, bounded per host. */
+const PENDING_ASK_CAP = 500;
+/** The audit ledger is trimmed to this many newest lines... */
+const AUDIT_KEEP = 5e3;
+/** ...checked once every this many appends per app. */
+const AUDIT_TRIM_EVERY = 500;
+/**
+* The host's tool gateway: every tool call any app session makes — chat,
+* cron, app routes; built-in, MCP, subagent — is decided here (see
+* `SessionOptions.toolGate`). Layers, in order:
+*
+* 1. the manifest policy (rules, then `allowedTools`/`askTools` sugar);
+* 2. the user's overrides (`policy.json`, plus legacy `grants.json`) — which
+*    may tighten anything but never loosen past a manifest `deny`;
+* 3. session grants ("approve for session"), keyed by the rule that asked;
+*
+* and every decision is appended to the app's `tool-calls.jsonl` audit
+* ledger. `ask` verdicts go on to the provider's interactive approval flow;
+* `applyDecision` turns the user's answer into a session grant or a
+* persistent user rule.
+*/
+var ToolGateway = class {
+	#store;
+	#sessionGrants = /* @__PURE__ */ new Map();
+	#pendingAsks = /* @__PURE__ */ new Map();
+	#appendCounts = /* @__PURE__ */ new Map();
+	/** Serializes ledger appends/trims and policy.json writes. */
+	#queue = Promise.resolve();
+	constructor(store) {
+		this.#store = store;
+	}
+	/** Builds the gate for one new session of `app`. */
+	session(app, manifestPolicy) {
+		const sessionKey = randomUUID();
+		const gate = async (call) => this.#decide(app, sessionKey, manifestPolicy, call);
+		return {
+			gate,
+			end: () => this.#sessionGrants.delete(sessionKey)
+		};
+	}
+	/** The user override layer as stored: policy.json rules, then legacy grants. */
+	async userPolicy(app) {
+		const [policy, grants] = await Promise.all([this.#store.readUserPolicy(app), this.#store.readGrants(app)]);
+		return { rules: [...policy.rules, ...grants.tools.map((tool) => ({
+			id: `grants.${tool}`,
+			tool,
+			decision: "allow"
+		}))] };
+	}
+	/**
+	* Applies the scope of a user's answer to a call this gateway sent to
+	* `ask`: `session` grants the asking rule for the rest of the session,
+	* `always` appends an allow rule with the asking rule's scope to the app's
+	* policy.json. Returns false for approvals this gateway never saw (legacy
+	* name-level sessions), so the caller can fall back.
+	*/
+	async applyDecision(approvalId, decision) {
+		const pending = this.#pendingAsks.get(approvalId);
+		if (!pending) return false;
+		this.#pendingAsks.delete(approvalId);
+		if (decision.behavior !== "allow") return true;
+		if (decision.scope === "session" || decision.scope === "always") {
+			let grants = this.#sessionGrants.get(pending.sessionKey);
+			if (!grants) {
+				grants = /* @__PURE__ */ new Set();
+				this.#sessionGrants.set(pending.sessionKey, grants);
+			}
+			grants.add(pending.grantKey);
+		}
+		if (decision.scope === "always") await this.#persistAlways(pending);
+		return true;
+	}
+	/** The newest audit lines for an app, newest last. */
+	async recentCalls(app, limit = 100) {
+		await this.flush();
+		return (await this.#store.readToolCalls(app)).slice(-limit);
+	}
+	/** Resolves when queued ledger and policy writes have landed (tests). */
+	flush() {
+		return this.#queue.then(() => void 0);
+	}
+	async #decide(app, sessionKey, manifestPolicy, call) {
+		const manifest = evaluatePolicy(manifestPolicy, call);
+		let verdict = manifest;
+		let source = manifest.ruleId !== void 0 ? "manifest" : "default";
+		if (manifest.decision !== "deny") {
+			const user = evaluatePolicy(compilePolicy({
+				default: "deny",
+				...await this.userPolicy(app)
+			}), call);
+			if (user.ruleId !== void 0) {
+				verdict = user;
+				source = "user";
+			}
+		}
+		let result;
+		if (verdict.decision === "ask") {
+			const grantKey = verdict.ruleId ?? `default:${call.tool}`;
+			if (this.#sessionGrants.get(sessionKey)?.has(grantKey)) {
+				source = "session";
+				result = { decision: "allow" };
+			} else {
+				this.#trackAsk(call.toolUseId, {
+					app,
+					sessionKey,
+					grantKey,
+					tool: call.tool,
+					...verdict.rule !== void 0 && { rule: verdict.rule }
+				});
+				result = {
+					decision: "ask",
+					...verdict.ruleId !== void 0 && { ruleId: verdict.ruleId },
+					reason: verdict.reason
+				};
+			}
+		} else if (verdict.decision === "allow") result = { decision: "allow" };
+		else result = {
+			decision: "deny",
+			reason: `Denied by policy: ${verdict.reason}`
+		};
+		this.#audit(app, {
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			tool: call.tool,
+			toolUseId: call.toolUseId,
+			inputPreview: preview(call.input),
+			decision: result.decision,
+			source,
+			...verdict.ruleId !== void 0 && { ruleId: verdict.ruleId },
+			reason: source === "session" ? `session grant: ${verdict.reason}` : verdict.reason
+		});
+		return result;
+	}
+	#trackAsk(toolUseId, pending) {
+		this.#pendingAsks.set(toolUseId, pending);
+		if (this.#pendingAsks.size > PENDING_ASK_CAP) {
+			const oldest = this.#pendingAsks.keys().next().value;
+			if (oldest !== void 0) this.#pendingAsks.delete(oldest);
+		}
+	}
+	#persistAlways(pending) {
+		const scope = pending.rule ?? {
+			tool: pending.tool,
+			decision: "ask"
+		};
+		const rule = {
+			id: `always.${pending.grantKey}`,
+			tool: scope.tool,
+			...scope.input !== void 0 && { input: scope.input },
+			decision: "allow",
+			description: `Always allowed: ${describeRule(scope)}`
+		};
+		const write = this.#queue.then(async () => {
+			const policy = await this.#store.readUserPolicy(pending.app);
+			if (policy.rules.some((existing) => existing.id === rule.id)) return;
+			policy.rules.unshift(rule);
+			await this.#store.writeUserPolicy(pending.app, policy);
+		});
+		this.#queue = write.catch(() => void 0);
+		return write;
+	}
+	#audit(app, record) {
+		const write = this.#queue.then(async () => {
+			await this.#store.appendToolCall(app, record);
+			const count = (this.#appendCounts.get(app) ?? 0) + 1;
+			this.#appendCounts.set(app, count);
+			if (count % AUDIT_TRIM_EVERY === 0) {
+				const records = await this.#store.readToolCalls(app);
+				if (records.length > AUDIT_KEEP) await this.#store.writeToolCalls(app, records.slice(-5e3));
+			}
+		});
+		this.#queue = write.catch((err) => {
+			console.warn(`alashi: failed to write tool-call audit for "${app}": ${String(err)}`);
+		});
+	}
+};
+function preview(input) {
+	let json;
+	try {
+		json = JSON.stringify(input) ?? String(input);
+	} catch {
+		json = String(input);
+	}
+	return json.length > INPUT_PREVIEW_CHARS ? `${json.slice(0, INPUT_PREVIEW_CHARS)}…` : json;
+}
+//#endregion
 //#region src/server.ts
 const CONTENT_TYPES = {
 	".html": "text/html; charset=utf-8",
@@ -2689,8 +2990,11 @@ function appErrorPage(name, err) {
 *                               optionally adopting an existing provider session (e.g. an
 *                               app-run investigation) so chat continues where it left off
 *   GET  /api/apps/:name/chat/:conversationId/history  past turns from the provider transcript
+*                               plus the conversation's settled approval records
 *   GET  /api/apps/:name/jobs           manifest-declared jobs with schedule/status
 *   POST /api/apps/:name/jobs/:job/run  trigger a job now (409 while already running)
+*   GET  /api/apps/:name/policy         effective tool policy: user overrides + manifest rules
+*   GET  /api/apps/:name/tool-calls?limit=  newest gated tool calls (audit ledger)
 *   GET  /api/apps/:name/manifest       read-only app definition: instructions, agents,
 *                                       skills (with dir contents), allowed tools,
 *                                       MCP servers (with configured state), jobs, model
@@ -2709,6 +3013,7 @@ function createServer(store, provider, options = {}) {
 	const sessions = /* @__PURE__ */ new Map();
 	const usage = new UsageRecorder(store);
 	const approvals = new ApprovalRegistry(store);
+	const gateway = new ToolGateway(store);
 	approvals.init().catch((err) => {
 		console.warn(`alashi: failed to read approval timeout config: ${String(err)}`);
 	});
@@ -2719,7 +3024,7 @@ function createServer(store, provider, options = {}) {
 	});
 	async function startApp(name) {
 		const { definition, manifest } = await loadApp(store.appRepoDir(name));
-		const ctx = await buildAppContext(store, manifest, provider, usage, approvals);
+		const ctx = await buildAppContext(store, manifest, provider, usage, approvals, gateway);
 		return {
 			manifest,
 			ctx,
@@ -3073,7 +3378,12 @@ ${approvalsSection}
 		const convo = conversations.find((conv) => conv.id === conversationId);
 		if (!convo) return c.json({ error: "Unknown conversation" }, 404);
 		const messages = convo.sessionId ? await provider.history?.(convo.sessionId) ?? [] : [];
-		return c.json({ messages });
+		await approvals.flush();
+		const settled = (await store.readApprovalLog(name)).approvals.filter((entry) => entry.conversationId === conversationId && entry.status !== "pending");
+		return c.json({
+			messages,
+			approvals: settled
+		});
 	});
 	/** Drops the cached app and its warm sessions so the next request rebuilds with fresh config. */
 	function restartApp(name) {
@@ -3084,6 +3394,33 @@ ${approvalsSection}
 			session.then((s) => s.close()).catch(() => void 0);
 		}
 	}
+	app.get("/api/apps/:name/policy", async (c) => {
+		const name = c.req.param("name");
+		const running = await getApp(name);
+		if (!running) return c.json({ error: `App "${name}" is not installed` }, 404);
+		const manifestPolicy = permissionsPolicy(running.manifest.permissions);
+		const user = await gateway.userPolicy(name);
+		const describe = (rule) => ({
+			...rule,
+			summary: describeRule(rule)
+		});
+		return c.json({
+			gated: provider.supportsToolGate === true && provider.supportsApprovals === true,
+			default: manifestPolicy.default,
+			user: user.rules.map(describe),
+			manifest: manifestPolicy.rules.map((rule, index) => describe({
+				...rule,
+				id: rule.id ?? `rules.${index}`
+			}))
+		});
+	});
+	app.get("/api/apps/:name/tool-calls", async (c) => {
+		const name = c.req.param("name");
+		if (!await getApp(name)) return c.json({ error: `App "${name}" is not installed` }, 404);
+		const raw = Number(c.req.query("limit") ?? 100);
+		const limit = Number.isInteger(raw) && raw > 0 ? Math.min(raw, 1e3) : 100;
+		return c.json({ calls: await gateway.recentCalls(name, limit) });
+	});
 	app.get("/api/apps/:name/manifest", async (c) => {
 		const name = c.req.param("name");
 		const running = await getApp(name);
@@ -3314,7 +3651,13 @@ ${approvalsSection}
 		if (!decision) return c.json({ error: "Body must be { \"behavior\": \"allow\"|\"deny\", \"scope\"?, \"message\"? }" }, 400);
 		const record = approvals.get(approvalId);
 		if (!record || expect !== void 0 && (record.app !== expect.app || expect.conversationId !== void 0 && record.conversationId !== expect.conversationId)) return c.json({ error: `Unknown approval "${approvalId}"` }, 404);
-		if (decision.behavior === "allow" && decision.scope === "always") {
+		let gatewayHandled;
+		try {
+			gatewayHandled = record.status === "pending" && await gateway.applyDecision(approvalId, decision);
+		} catch (err) {
+			return c.json({ error: `Failed to persist grant: ${String(err)}` }, 500);
+		}
+		if (!gatewayHandled && decision.behavior === "allow" && decision.scope === "always") {
 			const running = await getApp(record.app);
 			if (running) try {
 				await approvals.addGrant(record.app, record.tool, running.manifest.permissions.askTools);
@@ -3447,6 +3790,12 @@ var Store = class {
 	appGrantsPath(name) {
 		return join(this.appDir(name), "grants.json");
 	}
+	appPolicyPath(name) {
+		return join(this.appDir(name), "policy.json");
+	}
+	appToolCallsPath(name) {
+		return join(this.appDir(name), "tool-calls.jsonl");
+	}
 	appUsagePath(name) {
 		return join(this.appDir(name), "usage.json");
 	}
@@ -3493,6 +3842,49 @@ var Store = class {
 	async writeGrants(name, state) {
 		await writeJson(this.appGrantsPath(name), state);
 	}
+	async readUserPolicy(name) {
+		const state = await readJson(this.appPolicyPath(name));
+		return { rules: Array.isArray(state?.rules) ? state.rules : [] };
+	}
+	async writeUserPolicy(name, policy) {
+		await writeJson(this.appPolicyPath(name), policy);
+	}
+	/** Appends one line to the app's tool-call audit ledger. */
+	async appendToolCall(name, record) {
+		const path = this.appToolCallsPath(name);
+		await mkdir(join(path, ".."), { recursive: true });
+		await appendFile(path, `${JSON.stringify(record)}\n`, "utf8");
+	}
+	/**
+	* Parseable lines of the tool-call ledger, oldest first. Like the turn
+	* ledger, a truncated or hand-mangled line costs only itself.
+	*/
+	async readToolCalls(name) {
+		let content;
+		try {
+			content = await readFile(this.appToolCallsPath(name), "utf8");
+		} catch (err) {
+			if (err.code === "ENOENT") return [];
+			throw err;
+		}
+		const records = [];
+		for (const line of content.split("\n")) {
+			if (line.trim() === "") continue;
+			try {
+				const record = JSON.parse(line);
+				if (typeof record?.at === "string" && typeof record.tool === "string") records.push(record);
+			} catch {}
+		}
+		return records;
+	}
+	/** Replaces the tool-call ledger atomically (tmp file + rename), for trimming. */
+	async writeToolCalls(name, records) {
+		const path = this.appToolCallsPath(name);
+		await mkdir(join(path, ".."), { recursive: true });
+		const tmp = `${path}.tmp`;
+		await writeFile(tmp, records.map((r) => `${JSON.stringify(r)}\n`).join(""), "utf8");
+		await rename(tmp, path);
+	}
 	async readJobState(name) {
 		const state = await readJson(this.appJobStatePath(name));
 		return {
@@ -3591,4 +3983,4 @@ var Store = class {
 //#endregion
 export { UsageRecorder as A, BudgetExceededError as C, budgetStatusFor as D, budgetStatus as E, createAuthMiddleware as F, isConsoleRequest as I, registerAuthRoutes as L, utcDay as M, AuthService as N, setAppBudget as O, SESSION_COOKIE as P, requiredLevel as R, BUDGET_EXCEEDED_CODE as S, assertWithinBudget as T, fetchSource as _, EXPORT_FORMAT_VERSION as a, loadApp as b, installApp as c, updateApp as d, addRegistry as f, resolveApp as g, removeRegistry as h, resolveAppConfig as i, formatUsd as j, USAGE_RETENTION_DAYS as k, installDependencies as l, refreshRegistry as m, createServer as n, exportApp as o, readCachedIndex as p, buildAppContext as r, importApp as s, Store as t, removeApp as u, parseSourceArg as v, appBudget as w, checkSdkCompatibility as x, updateSource as y };
 
-//# sourceMappingURL=store-dipRcfKX.mjs.map
+//# sourceMappingURL=store-DvLX0Kft.mjs.map