@pablopunk/tau 0.0.0-stage → 0.1.1

package/dist/sdk-missing-CHbVbY1G.js

@@ -0,0 +1,10 @@
+//#region ../core/src/claude-cli/sdk-missing.ts
+var ClaudeSdkMissingError = class extends Error {
+	constructor() {
+		super("The Claude Agent SDK is not installed.");
+		this.name = "ClaudeSdkMissingError";
+	}
+};
+const isSdkMissing = (error) => error instanceof ClaudeSdkMissingError;
+//#endregion
+export { isSdkMissing as n, ClaudeSdkMissingError as t };

package/dist/sdk-port-BGw9ORUR.js

@@ -0,0 +1,215 @@
+import { t as ClaudeSdkMissingError } from "./sdk-missing-CHbVbY1G.js";
+import { n as buildToolServer } from "./tool-server-BjP37EJg.js";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+import { readFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+//#region ../core/src/claude-cli/auth-status.ts
+const AUTH_STATUS_TIMEOUT_MS = 5e3;
+const stringOrNull = (value) => typeof value === "string" ? value : null;
+/** Keeps only the four fields tau may read: never the email, ids or tokens. */
+function parseAuthStatus(stdout) {
+	const raw = JSON.parse(stdout);
+	if (typeof raw !== "object" || raw === null) throw new Error("claude auth status printed no object");
+	const fields = raw;
+	return {
+		loggedIn: fields.loggedIn === true,
+		authMethod: stringOrNull(fields.authMethod),
+		subscriptionType: stringOrNull(fields.subscriptionType),
+		orgName: stringOrNull(fields.orgName)
+	};
+}
+const claudeBinary = (env) => env.TAU_CLAUDE_PATH ?? "claude";
+/** A logged-out CLI exits 1 but still prints the JSON, so a non-zero exit with output is an answer. */
+function runAuthStatus(env) {
+	return new Promise((resolve, reject) => {
+		execFile(claudeBinary(env), [
+			"auth",
+			"status",
+			"--json"
+		], {
+			timeout: AUTH_STATUS_TIMEOUT_MS,
+			env: { ...env }
+		}, (error, stdout) => {
+			if (stdout.trim() !== "") {
+				try {
+					resolve(parseAuthStatus(stdout));
+				} catch (parseError) {
+					reject(parseError);
+				}
+				return;
+			}
+			reject(error ?? /* @__PURE__ */ new Error("claude auth status printed nothing"));
+		});
+	});
+}
+//#endregion
+//#region ../core/src/claude-cli/sdk-port.ts
+const SDK_PACKAGE = "@anthropic-ai/claude-agent-sdk";
+const API_KEY_VARIABLES = ["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"];
+const toContextSummary = (usage) => {
+	const loadedMcpToolCounts = {};
+	for (const tool of usage.mcpTools) if (tool.isLoaded !== false) loadedMcpToolCounts[tool.serverName] = (loadedMcpToolCounts[tool.serverName] ?? 0) + 1;
+	return {
+		memoryFileCount: usage.memoryFiles.length,
+		loadedMcpToolCounts
+	};
+};
+const withoutApiKeys = (env) => Object.fromEntries(Object.entries(env).filter(([name]) => !API_KEY_VARIABLES.includes(name)));
+const toServerStatus = (server) => ({
+	name: server.name,
+	status: server.status,
+	source: server.source ?? server.scope ?? null,
+	error: server.error ?? null,
+	tools: (server.tools ?? []).map((tool) => ({
+		name: tool.name,
+		readOnly: tool.annotations?.readOnly === true
+	}))
+});
+const toSdkCanUseTool = (canUseTool) => (toolName, input, options) => canUseTool({
+	toolName,
+	input,
+	toolUseId: options.toolUseID,
+	signal: options.signal,
+	mcpServer: options.mcpServer ?? null
+});
+const mcpToggleOf = (query) => ({ toggleMcpServer: (name, enabled) => query.toggleMcpServer(name, enabled) });
+const mcpControlOf = (query) => ({ mcpServerStatus: async () => (await query.mcpServerStatus()).map(toServerStatus) });
+function sdkOptions(sdk, options) {
+	const toolServer = options.toolHost ? buildToolServer(sdk.createSdkMcpServer, options.toolHost) : void 0;
+	const { prompt: _prompt, toolHost: _host, canUseTool, env, ...rest } = options;
+	return {
+		...rest,
+		...canUseTool && { canUseTool: toSdkCanUseTool(canUseTool) },
+		env: withoutApiKeys(env),
+		...toolServer && { mcpServers: { ["tau"]: toolServer.config } }
+	};
+}
+function wrapQuery(query, exposeToggle) {
+	return {
+		[Symbol.asyncIterator]: () => query[Symbol.asyncIterator](),
+		interrupt: async () => void await query.interrupt(),
+		setModel: (model) => query.setModel(model),
+		applyFlagSettings: (settings) => query.applyFlagSettings({ ...settings }),
+		isAutoCompactEnabled: async () => (await query.getContextUsage()).isAutoCompactEnabled,
+		...mcpControlOf(query),
+		...exposeToggle && mcpToggleOf(query),
+		close: () => query.close()
+	};
+}
+const probeOptions = (options) => ({
+	cwd: tmpdir(),
+	settingSources: options.settingSources ?? [],
+	tools: [],
+	strictMcpConfig: false,
+	settings: { disableClaudeAiConnectors: false },
+	permissionMode: "dontAsk",
+	env: withoutApiKeys(process.env)
+});
+function startProbe(sdk, options, exposeToggle) {
+	let release = () => void 0;
+	const neverSendsAPrompt = (async function* () {
+		await new Promise((resolve) => release = resolve);
+	})();
+	const query = sdk.query({
+		prompt: neverSendsAPrompt,
+		options: probeOptions(options)
+	});
+	return {
+		...mcpControlOf(query),
+		...exposeToggle && mcpToggleOf(query),
+		contextSummary: async () => toContextSummary(await query.getContextUsage()),
+		close() {
+			release();
+			query.close();
+		}
+	};
+}
+const idleOptions = () => ({
+	cwd: tmpdir(),
+	settingSources: [],
+	tools: [],
+	strictMcpConfig: true,
+	settings: { disableClaudeAiConnectors: true },
+	env: withoutApiKeys(process.env)
+});
+async function withIdleQuery(sdk, use) {
+	let release = () => void 0;
+	const neverSendsAPrompt = (async function* () {
+		await new Promise((resolve) => release = resolve);
+	})();
+	const query = sdk.query({
+		prompt: neverSendsAPrompt,
+		options: idleOptions()
+	});
+	try {
+		return await use(query);
+	} finally {
+		release();
+		query.close();
+	}
+}
+async function readBundledCliVersion(entry) {
+	const manifest = JSON.parse(await readFile(join(dirname(entry), "package.json"), "utf8"));
+	if (!manifest.claudeCodeVersion) throw new Error("The Agent SDK package has no claudeCodeVersion.");
+	return manifest.claudeCodeVersion;
+}
+const toModelOption = (model) => ({
+	value: model.value,
+	resolvedModel: model.resolvedModel ?? null,
+	displayName: model.displayName,
+	description: model.description,
+	supportedEffortLevels: model.supportedEffortLevels ?? [],
+	supportsThinkingOff: model.supportsThinkingOff ?? false
+});
+const toAccountInfo = (info) => ({
+	organization: info.organization ?? null,
+	subscriptionType: info.subscriptionType ?? null
+});
+function portOf(sdk, entry, exposeToggle) {
+	return {
+		authStatus: () => runAuthStatus(process.env),
+		accountInfo: () => withIdleQuery(sdk, async (query) => toAccountInfo(await query.accountInfo())),
+		supportedModels: () => withIdleQuery(sdk, async (query) => (await query.supportedModels()).map(toModelOption)),
+		bundledCliVersion: () => readBundledCliVersion(entry),
+		startProbe: (options = {}) => startProbe(sdk, options, exposeToggle),
+		startQuery(options) {
+			return wrapQuery(sdk.query({
+				prompt: options.prompt,
+				options: sdkOptions(sdk, options)
+			}), exposeToggle);
+		},
+		deleteSession: (sessionId) => sdk.deleteSession(sessionId)
+	};
+}
+const resolveInSdkHome = (sdkHome) => {
+	try {
+		return createRequire(join(sdkHome, "package.json")).resolve(SDK_PACKAGE);
+	} catch {
+		return null;
+	}
+};
+const resolveInDevelopment = () => {
+	try {
+		return createRequire(import.meta.url).resolve(SDK_PACKAGE);
+	} catch {
+		return null;
+	}
+};
+async function importSdk(sdkHome) {
+	const entry = sdkHome && resolveInSdkHome(sdkHome) || resolveInDevelopment();
+	if (!entry) throw new ClaudeSdkMissingError();
+	return {
+		sdk: await import(pathToFileURL(entry).href),
+		entry
+	};
+}
+/** The only place the Agent SDK is loaded. Nothing imports it while the kill switch is on. */
+async function loadClaudeSdkPort(sdkHome, options = {}) {
+	const { sdk, entry } = await importSdk(sdkHome);
+	return portOf(sdk, entry, options.exposeToggleForPins ?? false);
+}
+//#endregion
+export { loadClaudeSdkPort };