@pablopunk/tau 0.0.0-stage → 0.1.1

package/dist/fake-claude-thread-script-2iHHwUZM.js

@@ -0,0 +1,48 @@
+//#region ../core/src/claude-cli/testing/fake-claude-thread-script.ts
+const FAKE_CLAUDE_REPLY = "Fake Claude reply.";
+const FAKE_CLAUDE_TOOL_REPLY = "Fake Claude ran the tool.";
+const TOOL_COMMAND = /^(bash|read) (.+)/s;
+const toolArguments = (tool, rest) => tool === "bash" ? { command: rest } : { path: rest };
+function toolSteps(tool, rest) {
+	return [{
+		kind: "tools",
+		calls: [{
+			name: tool,
+			arguments: toolArguments(tool, rest)
+		}]
+	}, {
+		kind: "text",
+		text: FAKE_CLAUDE_TOOL_REPLY
+	}];
+}
+const CONNECTOR_COMMAND = /^connector (\S+) (\S+)/;
+const fakeConnectorResult = (tool) => `Fake connector result for ${tool}.`;
+function connectorSteps(server, tool) {
+	return [{
+		kind: "tools",
+		calls: [{
+			name: tool,
+			arguments: {},
+			connector: {
+				server: `claude.ai ${server}`,
+				result: fakeConnectorResult(tool)
+			}
+		}]
+	}, {
+		kind: "text",
+		text: FAKE_CLAUDE_TOOL_REPLY
+	}];
+}
+/** The script behind `TAU_FAKE_CLAUDE_CLI=1`: "bash <command>" and "read <path>" call that Pi tool, anything else gets a reply. */
+const fakeThreadScript = (_turn, firstUserText, hasTools) => {
+	const connector = hasTools ? CONNECTOR_COMMAND.exec(firstUserText.trim()) : null;
+	if (connector?.[1] && connector[2]) return connectorSteps(connector[1], connector[2]);
+	const match = hasTools ? TOOL_COMMAND.exec(firstUserText.trim()) : null;
+	if (match?.[1] && match[2]) return toolSteps(match[1], match[2]);
+	return [{
+		kind: "text",
+		text: FAKE_CLAUDE_REPLY
+	}];
+};
+//#endregion
+export { fakeThreadScript };

package/dist/last-exit-write-ksHeHGrC.js

@@ -0,0 +1,9 @@
+import { appendFileSync, writeFileSync } from "node:fs";
+//#region ../core/src/watchdog/last-exit-write.ts
+/** Synchronous on purpose: the watchdog writes this just before it kills the process. */
+function writeLastExitSync(file, logFile, exit) {
+	writeFileSync(file, `${JSON.stringify(exit)}\n`, { mode: 384 });
+	if (logFile && exit.reason === "watchdog") appendFileSync(logFile, `tau: watchdog killed the server (${exit.detail ?? exit.reason})\n`);
+}
+//#endregion
+export { writeLastExitSync as t };

package/dist/latest-version-di9hD7cY.js

@@ -0,0 +1,106 @@
+import { l as isPlainVersion } from "./src-DO9LUlhi.js";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+//#region src/private-files.ts
+const PRIVATE_DIRECTORY_MODE = 448;
+const PRIVATE_FILE_MODE = 384;
+async function ensurePrivateDirectory(path) {
+	await mkdir(path, {
+		recursive: true,
+		mode: PRIVATE_DIRECTORY_MODE
+	});
+}
+/** Temp file, then rename, so readers never see a half-written file. */
+async function writePrivateFile(path, content) {
+	await ensurePrivateDirectory(dirname(path));
+	const temporary = `${path}.${process.pid}.tmp`;
+	await writeFile(temporary, content, { mode: PRIVATE_FILE_MODE });
+	await rename(temporary, path);
+}
+//#endregion
+//#region src/token.ts
+const TOKEN_BYTES = 32;
+const MIN_TOKEN_LENGTH = 32;
+const tokenPath = (home) => join(home, "token");
+async function readExistingToken(home) {
+	try {
+		const token = (await readFile(tokenPath(home), "utf8")).trim();
+		return token.length >= MIN_TOKEN_LENGTH ? token : void 0;
+	} catch {
+		return;
+	}
+}
+/** The token outlives restarts so open browser tabs keep their cookie. */
+async function readOrCreateToken(home) {
+	const existing = await readExistingToken(home);
+	if (existing) return existing;
+	const token = randomBytes(TOKEN_BYTES).toString("base64url");
+	await writePrivateFile(tokenPath(home), `${token}\n`);
+	return token;
+}
+//#endregion
+//#region src/version.ts
+/** From the `package.json` next to `src/` and next to `dist/`. */
+function cliVersion() {
+	return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+}
+//#endregion
+//#region src/update/command-runner.ts
+/** Spawns with an args array and no shell. A missing binary is a result with `code: null`. */
+const spawnCommand = (command, args, options) => new Promise((resolve) => {
+	const child = spawn(command, [...args], {
+		env: options.env ?? process.env,
+		stdio: options.stdio === "inherit" ? "inherit" : [
+			"inherit",
+			options.stdio === "tee" ? "inherit" : "pipe",
+			"pipe"
+		],
+		timeout: options.timeoutMs
+	});
+	let stdout = "";
+	let stderr = "";
+	child.stdout?.on("data", (chunk) => {
+		stdout += chunk.toString();
+	});
+	child.stderr?.on("data", (chunk) => {
+		stderr += chunk.toString();
+		if (options.stdio === "tee") process.stderr.write(chunk);
+	});
+	child.on("error", (error) => resolve({
+		code: null,
+		stdout,
+		stderr: stderr + error.message
+	}));
+	child.on("close", (code) => resolve({
+		code,
+		stdout,
+		stderr
+	}));
+});
+//#endregion
+//#region src/update/latest-version.ts
+const PACKAGE_NAME = "@pablopunk/tau";
+const VIEW_TIMEOUT_MS = 15e3;
+const npmOf = (execPath) => join(dirname(execPath), "npm");
+/** The registry's `latest` as plain `x.y.z`; anything else is an error. */
+async function fetchLatestVersion(run, execPath) {
+	const args = [
+		"view",
+		`${PACKAGE_NAME}@latest`,
+		"version",
+		"--prefer-online"
+	];
+	const result = await run(npmOf(execPath), args, {
+		stdio: "capture",
+		timeoutMs: VIEW_TIMEOUT_MS
+	});
+	if (result.code !== 0) throw new Error(`Could not read the latest version from the npm registry (${result.stderr.trim().split("\n")[0] || `exit ${result.code}`}).`);
+	const version = result.stdout.trim();
+	if (!isPlainVersion(version)) throw new Error(`The registry returned an unexpected version: ${version}`);
+	return version;
+}
+//#endregion
+export { cliVersion as a, writePrivateFile as c, spawnCommand as i, fetchLatestVersion as n, readOrCreateToken as o, npmOf as r, ensurePrivateDirectory as s, PACKAGE_NAME as t };