@harnessforce/cli 0.4.0 → 0.4.1

package/README.md

@@ -2,11 +2,11 @@
 
 `harnessforce`, the command line of [Harnessforce](https://github.com/lambda-script/harnessforce-agent). It
 connects a machine to a Harnessforce Workspace, supplies the ingest key to Claude Code's OpenTelemetry
-exporter, launches an agent linked to an Issue, and imports the metadata of past Claude Code sessions.
+exporter, launches an agent linked to an Issue, and imports the metadata of past Claude Code and Codex sessions.
 
 It is used together with the `harnessforce` Claude Code plugin, whose `/harnessforce:setup` installs
-it. Public distribution on npm starts once the production domain of Harnessforce is decided; until
-then, install it from the [local marketplace build](https://github.com/lambda-script/harnessforce-agent/blob/main/docs/runbooks/local-marketplace.md).
+it. It is published on npm. To connect to a staging or local Harnessforce instead, install it from the
+[local marketplace build](https://github.com/lambda-script/harnessforce-agent/blob/main/docs/runbooks/local-marketplace.md).
 
 ## Requirements
 
@@ -30,7 +30,7 @@ harnessforce init
 | `harnessforce init [--port <port>] [--send-content] [--no-plugin-auto-update]` | Logs in with the browser, stores a user ingest key and an API token in the keychain, and configures Claude Code and Codex |
 | `harnessforce otel-headers` | Prints the `Authorization` header for Claude Code's `otelHeadersHelper`. Exits 3 when there is no key, 4 when the destination differs from the pinned origin, 5 while the CLI version is unsupported, and 1 on other failures. On Linux, after printing a key read from the kernel keyring, it moves that Workspace's items to an unlocked Secret Service (not when the hook starts it), so a reboot does not lose them |
 | `harnessforce run --issue <identifier> -- <agent> [args]` | Launches an agent with its session linked to an Issue |
-| `harnessforce import` | Sends the metadata of past Claude Code sessions in connected repositories |
+| `harnessforce import` | Sends the metadata of past Claude Code and Codex sessions in connected repositories |
 | `harnessforce status [--json]` | Shows the connected Workspace, your role, the setup steps that remain with their URLs, and whether the `origin` repository of the current directory is connected to the GitHub App. Reads only; the remote URL is compared on this machine and never sent. Exits 0 whenever the status was read |
 | `harnessforce tune [--all] [--no-send] [--show-report] [--json]` | Analyzes past sessions on this machine by public rules and sends the counts (analysis reports) |
 | `harnessforce tune --report-only [--all]` | Analyzes and sends like `harnessforce tune`, but writes nothing to stdout. Meant for your OS scheduler |
@@ -117,7 +117,9 @@ tokens are sent only to the origins pinned by `harnessforce init`.
 1. It checks the OS keychain first: macOS Keychain or the Windows Credential Manager (through
    [`@napi-rs/keyring`](https://github.com/Brooooooklyn/keyring-node)). On Linux it writes and deletes
    a non-secret `availability-probe` item in the Secret Service (GNOME Keyring or KWallet), waiting at
-   most 60 seconds for you to unlock it, and saves there when that works. Otherwise, as on a machine
+   most 60 seconds for you to unlock it, and saves there when that works. With KWallet it also says
+   which window asks for the password: KWallet shows one unlock window at a time, so an earlier
+   unanswered window behind other windows keeps the new one from appearing. Otherwise, as on a machine
    reached only over SSH, it saves to the kernel's persistent keyring, which lives in memory and is
    cleared on reboot or after a period of disuse; run `harnessforce init` again then. Without either
    store it stops. Keys are never written to a plain file.
@@ -137,7 +139,9 @@ tokens are sent only to the origins pinned by `harnessforce init`.
    them last, so a failure part way never pairs an old origin with a new key or token. After saving to
    the Secret Service it deletes the same Workspace's items from the kernel keyring. Later commands read
    a Workspace from the kernel keyring when it holds the ingest key there, and from the Secret Service
-   otherwise.
+   otherwise. Only `harnessforce init`, `run` and `import` ask a locked Secret Service for an unlock;
+   hooks and `harnessforce otel-headers` check the lock over D-Bus first and treat a locked item as
+   missing.
 5. It updates the Claude Code user settings (`~/.claude/settings.json`, or `$CLAUDE_CONFIG_DIR`),
    changing only these keys:
    - `env`: the OTel exporter variables, `HARNESSFORCE_URL`, `HARNESSFORCE_ENDPOINT` and
@@ -153,7 +157,7 @@ tokens are sent only to the origins pinned by `harnessforce init`.
    - `[otel].exporter`: OTLP/HTTP (`protocol = "binary"`) to the ingest endpoint with
      `Authorization = "Bearer <user ingest key>"`. Codex cannot take the header from a command or expand
      `${VAR}`, so this is the one place a key is written to a plain file. It is the user ingest key only
-     (never the API token), and you can revoke it on the Workspace's send keys page. `log_user_prompt` and
+     (never the API token), and you can revoke it in My ingest keys on your account page. `log_user_prompt` and
      `log_agent_responses` are set to `true` for a category you send with `--send-content` and the
      Workspace stores, and `false` otherwise
    - `[[hooks.SessionStart]]`: a handler that runs `harnessforce hook session-start`
@@ -170,12 +174,13 @@ tokens are sent only to the origins pinned by `harnessforce init`.
 `harnessforce otel-headers` prints `{"Authorization":"Bearer <key>"}`. The key is `HARNESSFORCE_INGEST_KEY` from
 the managed settings file when that is set, and otherwise the user key for
 `HARNESSFORCE_WORKSPACE_ID` from the keychain. If
-there is no key, it prints nothing and exits 1. The user key is printed only when every destination
+there is no key, it prints nothing and exits 3. The user key is printed only when every destination
 variable that is set (`HARNESSFORCE_ENDPOINT`, `OTEL_EXPORTER_OTLP_ENDPOINT` and the per-signal
 `OTEL_EXPORTER_OTLP_*_ENDPOINT`) has the pinned origin. This stops a repository's
 `.claude/settings.json` `env` from pointing the hook at another host to collect the key. Otherwise it
-writes `harnessforce: user key withheld (destination not verified)` to stderr and exits 1. Run
-`harnessforce init` again to re-pin.
+writes `harnessforce: user key withheld (destination not verified)` to stderr and exits 4. Run
+`harnessforce init` again to re-pin. While the CLI version is unsupported it exits 5 without reading
+the keychain, and any other failure (such as an unavailable keychain) exits 1.
 
 ### Refreshing the API token
 
@@ -242,15 +247,23 @@ It exits with the agent's exit code. Prompt and body logging are never turned on
 
 ## Importing past sessions (`harnessforce import`)
 
-`harnessforce import` sends metadata of past Claude Code sessions on this machine to Harnessforce, so that
-work done before the plugin was installed can be linked to issues too. Run `harnessforce init` first.
-
-- It reads the transcripts in `~/.claude/projects/<project>/<session>.jsonl` (or
-  `$CLAUDE_CONFIG_DIR/projects`). Their format is not documented, so the parser is versioned
-  (`parser_version`), and unreadable lines and files are skipped and counted.
-- Only these values are sent: session ID, first prompt ID, start and end time, repository, branch,
-  the most used model, input and output token counts (without cache tokens), and the number of calls
-  and failures per tool. Prompts, responses and tool inputs and outputs are never sent.
+`harnessforce import` sends metadata of past Claude Code and Codex sessions on this machine to Harnessforce,
+so that work done before the plugin was installed can be linked to issues too. Run `harnessforce init` first.
+
+- For Claude Code it reads the transcripts in `~/.claude/projects/<project>/<session>.jsonl`, or under
+  the `CLAUDE_CONFIG_DIR` set in the `env` of the managed settings file or of `~/.claude/settings.json`.
+  The `CLAUDE_CONFIG_DIR` of the process environment is not read, because a repository's
+  `.claude/settings.json` can change it.
+- For Codex it reads the rollouts in `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`. `CODEX_HOME` is not
+  read, for the same reason. Compressed rollouts (`.jsonl.zst`) and `archived_sessions` are not read; the
+  compressed ones in the import window are counted and reported.
+- The formats are not documented, so the parsers are versioned (`parser_version`), and unreadable lines
+  and files are skipped and counted.
+- Only these values are sent: agent, session ID, start and end time, repository, branch, the most used
+  model, input and output token counts (without cache tokens), and the number of calls per tool. Claude
+  Code sessions also send the first prompt ID and the number of failures per tool. Codex sessions also
+  send the commit the session started on, and no failure counts, because a rollout does not keep whether
+  every call succeeded. Prompts, responses and tool inputs and outputs are never sent.
 - Only sessions whose `cwd` is in a repository connected to the Workspace are sent. The connected
   repositories come from `GET <HARNESSFORCE_URL>/api/v1/repositories` (all pages) and the import
   window from `session_import_days` (`GET <HARNESSFORCE_URL>/api/v1/workspace`), both with the API
@@ -286,7 +299,7 @@ role cannot use it.
   commands, paths and error text never leave the machine.
 - By default it analyzes sessions started in the last 30 days in connected repositories. `--all`
   analyzes every session, but still sends only sessions in connected repositories that started within
-  `session_import_days`. Sessions without a Run are imported first, like `harnessforce import`.
+  `session_import_days`. Sessions that were not imported yet are imported first, like `harnessforce import`.
 - Sending is fail-open: when Harnessforce cannot be reached, the reports stay in
   `~/.harnessforce/tune/unsent.json` and are sent by the next run. `401` and `403` delete the unsent
   reports and ask you to run `harnessforce init`.

package/dist/bin.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
+import { access, chmod, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
 import { constants, homedir, tmpdir } from "node:os";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { basename, dirname, isAbsolute, join, posix, resolve, win32 } from "node:path";
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { access, chmod, lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, stat, utimes, writeFile } from "node:fs/promises";
 import { execFile, spawn } from "node:child_process";
 import { constants as constants$1, createReadStream } from "node:fs";
+import { connect } from "node:net";
 import { createServer } from "node:http";
 import { ATTR, INTERVENTION_KINDS, LOOP_KINDS, MAX_WORK_LOCATIONS, PROPOSAL_KINDS, isToken, normalizeRepository } from "@harnessforce/semconv";
 import { createInterface } from "node:readline";
@@ -434,6 +435,7 @@ const INIT_MESSAGES = {
 	contentNotStored: "This workspace does not store content, so sending content was not enabled. An owner or admin can turn it on under Collection & retention in the workspace settings, then run `harnessforce init --send-content` again",
 	contentNotSent: "Content is not sent from this machine. Run `harnessforce init --send-content` to send it"
 };
+const kwalletUnlockHint = (walletLabel = "kdewallet") => `KWallet asks for the password of the wallet "${walletLabel}" in a "KDE Wallet Service" window. If no window appears, an earlier request may be waiting behind other windows: answer that window, or log out and back in, then run \`harnessforce init\` again`;
 const codexNotes = (configPath) => [
 	`Wrote the Codex configuration (${configPath}). Restart Codex to apply it`,
 	"Codex hooks do not run until you trust them in Codex's /hooks. Trust the harnessforce SessionStart, PostToolUse, and Stop hooks in /hooks",
@@ -479,6 +481,7 @@ const apiTokenWorkspaceId = (account) => account.endsWith(API_TOKEN_SUFFIX) ? ac
 // src/credentials/linux-keychain.ts
 const SECRET_SERVICE_TIMEOUT_MS = 6e4;
 const WAITING_NOTICE_DELAY_MS = 2e3;
+const PROVIDER_TIMEOUT_MS = 500;
 const PROBE_ACCOUNT$1 = "availability-probe";
 const PROBE_VALUE = "harnessforce";
 const MIGRATION_PROBE_TIMEOUT_MS = 200;
@@ -487,10 +490,11 @@ const CLEANUP_TIMEOUT_MS = 200;
 const succeeds = (operation) => operation().then(() => true, () => false);
 const workspaceOf = (account) => account.slice(0, account.lastIndexOf(":"));
 function createLinuxKeychain(options) {
-	return build(options, SECRET_SERVICE_TIMEOUT_MS);
+	return build(options, SECRET_SERVICE_TIMEOUT_MS, true);
 }
-function build(options, timeoutMs) {
-	const { kernel, secretService } = options;
+function build(options, timeoutMs, allowsUnlockPrompt) {
+	const { kernel } = options;
+	const secretService = allowsUnlockPrompt ? options.secretService : options.secretService.withoutUnlockPrompt();
 	const locations = /* @__PURE__ */ new Map();
 	const locate = (workspaceId) => {
 		let located = locations.get(workspaceId);
@@ -535,7 +539,7 @@ function build(options, timeoutMs) {
 			if (location !== "kernel") return;
 			await migrate(options, workspaceId).catch(() => {});
 		},
-		withTimeout: (ms) => build(options, ms),
+		withTimeout: (ms) => build(options, ms, false),
 		openForInit: (init) => openForInit(options, timeoutMs, init)
 	};
 }
@@ -544,8 +548,17 @@ async function openForInit({ kernel, secretService }, timeoutMs, { previousWorks
 		await store.set(PROBE_ACCOUNT$1, PROBE_VALUE, timeoutMs);
 		await store.delete(PROBE_ACCOUNT$1, timeoutMs);
 	});
-	const notice = setTimeout(onWaiting, WAITING_NOTICE_DELAY_MS);
-	const usesSecretService = await canWrite(secretService).finally(() => clearTimeout(notice));
+	let isWaiting = true;
+	const notify = (provider) => {
+		if (isWaiting) onWaiting(provider);
+	};
+	const notice = setTimeout(() => {
+		secretService.provider(PROVIDER_TIMEOUT_MS).then(notify, () => notify(void 0));
+	}, WAITING_NOTICE_DELAY_MS);
+	const usesSecretService = await canWrite(secretService).finally(() => {
+		isWaiting = false;
+		clearTimeout(notice);
+	});
 	const readKernel = async () => {
 		if (!previousWorkspaceId) return [];
 		const accounts = [ingestKeyAccount(previousWorkspaceId), apiTokenAccount(previousWorkspaceId)];
@@ -584,7 +597,8 @@ const MIGRATION_ORDER = (workspaceId) => [
 	apiTokenAccount(workspaceId),
 	ingestKeyAccount(workspaceId)
 ];
-async function migrate({ kernel, secretService }, workspaceId) {
+async function migrate({ kernel, secretService: unlimited }, workspaceId) {
+	const secretService = unlimited.withoutUnlockPrompt();
 	let isExpired = false;
 	const deadline = Date.now() + MIGRATION_BUDGET_MS;
 	const remaining = () => {
@@ -712,6 +726,419 @@ const unsupported = {
 	withTimeout: () => unsupported,
 	openForInit: async () => void 0
 };
+// src/credentials/dbus.ts
+const TYPES = [
+	"",
+	"method_call",
+	"method_return",
+	"error",
+	"signal"
+];
+const FIELDS = {
+	path: [1, "o"],
+	interface: [2, "s"],
+	member: [3, "s"],
+	errorName: [4, "s"],
+	replySerial: [5, "u"],
+	destination: [6, "s"],
+	sender: [7, "s"],
+	signature: [8, "g"]
+};
+function parseSignature(signature) {
+	let index = 0;
+	const one = () => {
+		const code = signature[index++] ?? "";
+		if (code === "a") return {
+			code,
+			children: [one()]
+		};
+		if (code === "(" || code === "{") {
+			const close = code === "(" ? ")" : "}";
+			const children = [];
+			while (signature[index] !== close) {
+				if (index >= signature.length) throw new Error("bad signature");
+				children.push(one());
+			}
+			index++;
+			return {
+				code,
+				children
+			};
+		}
+		if (!"ybusogv".includes(code) || code === "") throw new Error(`unsupported D-Bus type ${code}`);
+		return {
+			code,
+			children: []
+		};
+	};
+	const types = [];
+	while (index < signature.length) types.push(one());
+	return types;
+}
+const alignmentOf = (type) => ({
+	y: 1,
+	g: 1,
+	v: 1,
+	b: 4,
+	u: 4,
+	s: 4,
+	o: 4,
+	a: 4
+})[type.code] ?? 8;
+var Writer = class {
+	bytes = [];
+	get length() {
+		return this.bytes.length;
+	}
+	align(n) {
+		while (this.bytes.length % n !== 0) this.bytes.push(0);
+	}
+	uint32(value) {
+		this.align(4);
+		const buffer = Buffer.alloc(4);
+		buffer.writeUInt32LE(value);
+		this.bytes.push(...buffer);
+	}
+	patchUint32(offset, value) {
+		const buffer = Buffer.alloc(4);
+		buffer.writeUInt32LE(value);
+		this.bytes.splice(offset, 4, ...buffer);
+	}
+	raw(values) {
+		this.bytes.push(...values);
+	}
+	write(type, value) {
+		const [child] = type.children;
+		switch (type.code) {
+			case "y":
+				this.raw([Number(value)]);
+				return;
+			case "b":
+				this.uint32(value ? 1 : 0);
+				return;
+			case "u":
+				this.uint32(Number(value));
+				return;
+			case "s":
+			case "o": {
+				const text = Buffer.from(String(value), "utf8");
+				this.uint32(text.length);
+				this.raw([...text, 0]);
+				return;
+			}
+			case "g": {
+				const text = Buffer.from(String(value), "utf8");
+				this.raw([
+					text.length,
+					...text,
+					0
+				]);
+				return;
+			}
+			case "v": {
+				const variant = value;
+				this.write({
+					code: "g",
+					children: []
+				}, variant.signature);
+				const [inner] = parseSignature(variant.signature);
+				if (!inner) throw new Error("empty variant");
+				this.write(inner, variant.value);
+				return;
+			}
+			case "a": {
+				if (!child) throw new Error("bad array");
+				this.uint32(0);
+				const lengthAt = this.length - 4;
+				this.align(alignmentOf(child));
+				const start = this.length;
+				const elements = child.code === "{" ? Object.entries(value) : value;
+				for (const element of elements) this.write(child, element);
+				this.patchUint32(lengthAt, this.length - start);
+				return;
+			}
+			default: {
+				this.align(8);
+				const fields = value;
+				type.children.forEach((field, i) => {
+					this.write(field, fields[i]);
+				});
+			}
+		}
+	}
+	toBuffer() {
+		return Buffer.from(this.bytes);
+	}
+};
+var Reader = class {
+	offset = 0;
+	buffer;
+	isLittleEndian;
+	constructor(buffer, isLittleEndian) {
+		this.buffer = buffer;
+		this.isLittleEndian = isLittleEndian;
+	}
+	align(n) {
+		this.offset = Math.ceil(this.offset / n) * n;
+	}
+	uint32() {
+		this.align(4);
+		const value = this.isLittleEndian ? this.buffer.readUInt32LE(this.offset) : this.buffer.readUInt32BE(this.offset);
+		this.offset += 4;
+		return value;
+	}
+	read(type) {
+		const [child] = type.children;
+		switch (type.code) {
+			case "y": return this.buffer[this.offset++];
+			case "b": return this.uint32() !== 0;
+			case "u": return this.uint32();
+			case "s":
+			case "o": {
+				const length = this.uint32();
+				const text = this.buffer.toString("utf8", this.offset, this.offset + length);
+				this.offset += length + 1;
+				return text;
+			}
+			case "g": {
+				const length = this.buffer[this.offset++] ?? 0;
+				const text = this.buffer.toString("utf8", this.offset, this.offset + length);
+				this.offset += length + 1;
+				return text;
+			}
+			case "v": {
+				const signature = this.read({
+					code: "g",
+					children: []
+				});
+				const [inner] = parseSignature(signature);
+				if (!inner) throw new Error("empty variant");
+				return {
+					signature,
+					value: this.read(inner)
+				};
+			}
+			case "a": {
+				if (!child) throw new Error("bad array");
+				const length = this.uint32();
+				this.align(alignmentOf(child));
+				const end = this.offset + length;
+				const elements = [];
+				while (this.offset < end) elements.push(this.read(child));
+				return child.code === "{" ? Object.fromEntries(elements) : elements;
+			}
+			default:
+				this.align(8);
+				return type.children.map((field) => this.read(field));
+		}
+	}
+};
+const HEADER_FIELDS = parseSignature("a(yv)")[0];
+function encodeMessage(message) {
+	const signature = message.signature ?? "";
+	const bodyWriter = new Writer();
+	parseSignature(signature).forEach((type, i) => {
+		bodyWriter.write(type, message.body?.[i]);
+	});
+	const body = bodyWriter.toBuffer();
+	const fields = [];
+	for (const [name, [code, fieldType]] of Object.entries(FIELDS)) {
+		const value = message[name];
+		if (value === void 0 || name === "signature" && value === "") continue;
+		fields.push([code, {
+			signature: fieldType,
+			value
+		}]);
+	}
+	const header = new Writer();
+	header.raw([
+		"l".charCodeAt(0),
+		TYPES.indexOf(message.type),
+		0,
+		1
+	]);
+	header.uint32(body.length);
+	header.uint32(message.serial);
+	header.write(HEADER_FIELDS, fields);
+	header.align(8);
+	return Buffer.concat([header.toBuffer(), body]);
+}
+function decodeMessages(buffer) {
+	const messages = [];
+	let rest = buffer;
+	while (rest.length >= 16) {
+		const isLittleEndian = rest[0] === "l".charCodeAt(0);
+		const readUint32 = (offset) => isLittleEndian ? rest.readUInt32LE(offset) : rest.readUInt32BE(offset);
+		const bodyLength = readUint32(4);
+		const fieldsLength = readUint32(12);
+		const headerLength = Math.ceil((16 + fieldsLength) / 8) * 8;
+		const total = headerLength + bodyLength;
+		if (rest.length < total) break;
+		const reader = new Reader(rest.subarray(0, total), isLittleEndian);
+		reader.offset = 8;
+		const serial = reader.uint32();
+		const fields = reader.read(HEADER_FIELDS);
+		const message = {
+			type: TYPES[rest[1] ?? 0] || "signal",
+			serial
+		};
+		for (const [code, { value }] of fields) {
+			const name = Object.entries(FIELDS).find(([, [c]]) => c === code)?.[0];
+			if (name) Object.assign(message, { [name]: value });
+		}
+		reader.offset = headerLength;
+		message.body = parseSignature(message.signature ?? "").map((type) => reader.read(type));
+		messages.push(message);
+		rest = rest.subarray(total);
+	}
+	return {
+		messages,
+		rest
+	};
+}
+function socketPath(address) {
+	for (const entry of address.split(";")) {
+		const [transport, rest = ""] = entry.split(/:(.*)/s);
+		if (transport !== "unix") continue;
+		const params = new Map(rest.split(",").map((pair) => pair.split(/=(.*)/s)));
+		const path = params.get("path");
+		if (path) return decodeURIComponent(path);
+		const abstract = params.get("abstract");
+		if (abstract) return `\0${decodeURIComponent(abstract)}`;
+	}
+}
+function openBus(address, uid, timeoutMs) {
+	const path = socketPath(address);
+	if (!path) return Promise.reject(/* @__PURE__ */ new Error("unsupported D-Bus address"));
+	return new Promise((resolve, reject) => {
+		const socket = connect({ path });
+		const waiting = /* @__PURE__ */ new Map();
+		let serial = 0;
+		let pending = Buffer.alloc(0);
+		let isAuthenticated = false;
+		const fail = (error) => {
+			socket.destroy();
+			reject(error);
+			for (const call of waiting.values()) call.reject(error);
+			waiting.clear();
+		};
+		const timer = setTimeout(() => fail(/* @__PURE__ */ new Error("D-Bus timed out")), timeoutMs);
+		const close = () => {
+			clearTimeout(timer);
+			socket.destroy();
+		};
+		const call = (request) => new Promise((resolveCall, rejectCall) => {
+			serial += 1;
+			waiting.set(serial, {
+				resolve: resolveCall,
+				reject: rejectCall
+			});
+			socket.write(encodeMessage({
+				type: "method_call",
+				serial,
+				...request
+			}));
+		});
+		socket.on("error", fail);
+		socket.on("close", () => fail(/* @__PURE__ */ new Error("D-Bus connection closed")));
+		socket.on("connect", () => {
+			const uidHex = Buffer.from(String(uid)).toString("hex");
+			socket.write(`\0AUTH EXTERNAL ${uidHex}\r\n`);
+		});
+		socket.on("data", (chunk) => {
+			pending = Buffer.concat([pending, chunk]);
+			if (!isAuthenticated) {
+				const lineEnd = pending.indexOf("\r\n");
+				if (lineEnd < 0) return;
+				const line = pending.toString("latin1", 0, lineEnd);
+				pending = pending.subarray(lineEnd + 2);
+				if (!line.startsWith("OK ")) return fail(/* @__PURE__ */ new Error("D-Bus authentication failed"));
+				isAuthenticated = true;
+				socket.write("BEGIN\r\n");
+				call({
+					destination: "org.freedesktop.DBus",
+					path: "/org/freedesktop/DBus",
+					interface: "org.freedesktop.DBus",
+					member: "Hello"
+				}).then(() => resolve({
+					call,
+					close
+				}), fail);
+			}
+			const { messages, rest } = decodeMessages(pending);
+			pending = rest;
+			for (const message of messages) {
+				const replied = message.replySerial === void 0 ? void 0 : waiting.get(message.replySerial);
+				if (!replied || message.replySerial === void 0) continue;
+				waiting.delete(message.replySerial);
+				if (message.type === "error") replied.reject(new Error(message.errorName ?? "D-Bus error"));
+				else replied.resolve(message.body ?? []);
+			}
+		});
+	});
+}
+// src/credentials/secret-service-lock.ts
+const SECRETS = "org.freedesktop.secrets";
+const SERVICE_PATH = "/org/freedesktop/secrets";
+const DEFAULT_COLLECTION = "/org/freedesktop/secrets/aliases/default";
+const KWALLET_PROCESS = /^(ksecretd|kwalletd\d*)$/;
+function sessionBusAddress(env) {
+	if (env.DBUS_SESSION_BUS_ADDRESS) return env.DBUS_SESSION_BUS_ADDRESS;
+	if (env.XDG_RUNTIME_DIR) return `unix:path=${env.XDG_RUNTIME_DIR}/bus`;
+}
+const property = (bus, name) => bus.call({
+	destination: SECRETS,
+	path: DEFAULT_COLLECTION,
+	interface: "org.freedesktop.DBus.Properties",
+	member: "Get",
+	signature: "ss",
+	body: ["org.freedesktop.Secret.Collection", name]
+}).then(([variant]) => variant.value);
+function createSecretServiceLock({ address, uid, readComm }) {
+	const withBus = async (timeoutMs, use) => {
+		if (!address) throw new Error("no D-Bus session bus");
+		const bus = await openBus(address, uid, timeoutMs);
+		try {
+			return await use(bus);
+		} finally {
+			bus.close();
+		}
+	};
+	return {
+		needsUnlock: (operation, account, timeoutMs) => withBus(timeoutMs, async (bus) => {
+			const [unlocked, locked] = await bus.call({
+				destination: SECRETS,
+				path: SERVICE_PATH,
+				interface: "org.freedesktop.Secret.Service",
+				member: "SearchItems",
+				signature: "a{ss}",
+				body: [{
+					service: KEYCHAIN_SERVICE,
+					username: account
+				}]
+			});
+			if (locked.length > 0) return true;
+			if (unlocked.length > 0 || operation !== "set") return false;
+			return property(bus, "Locked").then((isLocked) => isLocked === true, () => true);
+		}),
+		provider: (timeoutMs) => withBus(timeoutMs, async (bus) => {
+			const [pid] = await bus.call({
+				destination: "org.freedesktop.DBus",
+				path: "/org/freedesktop/DBus",
+				interface: "org.freedesktop.DBus",
+				member: "GetConnectionUnixProcessID",
+				signature: "s",
+				body: [SECRETS]
+			});
+			const comm = (await readComm(pid)).trim();
+			const label = await property(bus, "Label").catch(() => void 0);
+			return {
+				isKWallet: KWALLET_PROCESS.test(comm),
+				walletLabel: typeof label === "string" ? label : void 0
+			};
+		})
+	};
+}
 // src/credentials/secret-service-process.ts
 const CHILD_SCRIPT = `
 const [op, service, account, timeoutMs, modulePath] = process.argv.slice(1);
@@ -737,7 +1164,7 @@ process.stdin.on("end", async () => {
 	}
 });
 `;
-function createSecretServiceProcess({ execPath, resolveKeyring }) {
+function createSecretServiceProcess({ execPath, resolveKeyring, lock }) {
 	const run = (op, account, timeoutMs, input = "") => new Promise((resolve, reject) => {
 		const child = spawn(execPath, [
 			"-e",
@@ -768,17 +1195,29 @@ function createSecretServiceProcess({ execPath, resolveKeyring }) {
 		child.stdin.on("error", () => {});
 		child.stdin.end(input);
 	});
-	return {
+	const operations = (perform) => ({
 		async get(account, timeoutMs) {
-			const secret = await run("get", account, timeoutMs);
+			const secret = await perform("get", account, timeoutMs);
 			return typeof secret === "string" ? secret : void 0;
 		},
 		async set(account, secret, timeoutMs) {
-			await run("set", account, timeoutMs, secret);
+			await perform("set", account, timeoutMs, secret);
 		},
 		async delete(account, timeoutMs) {
-			await run("delete", account, timeoutMs);
-		},
+			await perform("delete", account, timeoutMs);
+		}
+	});
+	const withoutPrompt = async (op, account, timeoutMs, input) => {
+		const startedAt = Date.now();
+		if (await lock.needsUnlock(op, account, timeoutMs)) throw new Error("the Secret Service is locked");
+		const remainingMs = timeoutMs - (Date.now() - startedAt);
+		if (remainingMs <= 0) throw new Error("Secret Service timed out");
+		return run(op, account, remainingMs, input);
+	};
+	return {
+		...operations(run),
+		withoutUnlockPrompt: () => operations(withoutPrompt),
+		provider: (timeoutMs) => lock.provider(timeoutMs),
 		async list(timeoutMs) {
 			return (await run("list", "", timeoutMs)).map(({ account, password }) => ({
 				account,
@@ -1432,8 +1871,10 @@ What it does:
   and what to do next.
 
 Sends:
-  Per session: agent, session ID, repository, branch, commit, start and end
-  time, model, input and output token counts, and tool call counts.
+  Per session: agent, session ID, repository, branch, start and end time,
+  model, input and output token counts, and tool call counts. Claude Code
+  sessions also send the first prompt ID; Codex sessions also send the commit
+  the session started on.
 
 Does not send:
   Prompt text, model responses, tool input or output, and code diffs. Sessions
@@ -1498,8 +1939,12 @@ Does not send:
 
 Exit codes:
   0  Header printed.
-  1  No usable key (not logged in, keychain unavailable, or the destination was
-     not verified). Nothing is printed to stdout.
+  3  No key for the Workspace (not logged in, or the keychain item is gone, for
+     example after a reboot cleared the kernel keyring).
+  4  The destination was not verified: it differs from the origin init pinned.
+  5  This CLI version is unsupported. The keychain is not read.
+  1  Any other failure (keychain unavailable, read failed, or timed out).
+  Nothing is printed to stdout unless the exit code is 0.
 
 Examples:
   harnessforce otel-headers
@@ -1717,7 +2162,7 @@ const DESTINATION_MISMATCH_WARNING = {
 // ../agent-core/src/issue.ts
 const isIssueIdentifier = (value) => isToken(value, 300);
 // ../agent-core/src/using-harnessforce.ts
-const usingHarnessforceBody = "---\nname: using-harnessforce\ndescription: Use when starting a session in an environment with the Harnessforce hook, when starting work on an Issue, or when asked what is recorded or collected. The hook injects this text into the context at session start.\n---\n\n# Using Harnessforce\n\nThis session has the Harnessforce hook installed. Harnessforce links the work of people and AI to Issues and records it. Follow these rules.\n\n## What is recorded\n\n- Session registration: agent, session ID, repository, branch, commit, start time, and the first prompt ID.\n- Work locations: the repository and branch of each Git working tree the session works in. Paths are not sent.\n- Config snapshot: the structure of the configuration in use (Claude Code only).\n- OTel telemetry: what the user chooses to send.\n- For work on an Issue, `record-run` registers the session as a Run and closes it. It records no Plan, Decision, or Definition of Done.\n\n## What is not collected\n\n- Prompts, responses, tool input and output, and the body of code diffs arrive only when the user sends them (`--send-content` or managed settings) and the Workspace stores that category. The members the Workspace chooses can read them. `harnessforce import` never sends them.\n- Never put these contents, secrets, or environment variable values in MCP tool input or in a record.\n\n## Which hook sends what\n\n- SessionStart: session registration and the config snapshot (Codex sends session registration only).\n- UserPromptSubmit: resends on the first prompt (Claude Code only).\n- Stop: sends the work locations at the end of a turn in which they changed.\n- A failing hook never stops the session. When the hook cannot send, it shows a one-line warning. Tell the user when a warning appears.\n\n## Which skill and tool to use, and when\n\n- For work on a specified Issue ID, or when the environment variable `HARNESSFORCE_ISSUE` is set, follow `record-run` and use `start_run`, `get_issue`, and `complete_run`. An agent that cannot load the skill calls the tools in the same order.\n- Pass the value of the `harnessforce session_id:` line in the context to `start_run`. If there are several, use the last one. If the line is missing, do not guess the session ID, and do not call `start_run` or `complete_run`.\n- Use `propose-improvements` for the analysis of `/harnessforce:tune`.\n- When no Issue is specified, do not start recording a Run.\n\n## Red Flags\n\nStop when one of these thoughts comes up.\n\n| Thought | Reality |\n| --- | --- |\n| An Issue was specified, but the work is small, so recording is unnecessary | Work on a specified Issue is recorded regardless of its size |\n| The session ID line is missing, so I will guess it and call `start_run` | Do not guess. The Run would no longer be linked to the session |\n| Summarizing the content before recording would help | Do not pass content to the tool. It goes beyond what is collected |\n| A warning appeared, but I can ignore it | Sending is not working. Tell the user |\n\n## Priority\n\n1. The user's instructions (CLAUDE.md, AGENTS.md, direct requests). If the user tells you to stop recording, stop recording the Run.\n2. This introduction.\n3. Default behavior.\n\n## Subagents\n\nA subagent that was delegated only a specific task by its parent does not register a Run by following this introduction. The parent registers the Run.\n".replace(/\r\n/g, "\n").replace(/^---\n[\s\S]*?\n---\n+/, "").trimEnd();
+const usingHarnessforceBody = "---\nname: using-harnessforce\ndescription: Use when starting a session in an environment with the Harnessforce hook, when starting work on an Issue, or when asked what is recorded or collected. The hook injects this text into the context at session start.\n---\n\n# Using Harnessforce\n\nThis session has the Harnessforce hook installed. Harnessforce links the work of people and AI to Issues and records it. Follow these rules.\n\n## What is recorded\n\n- Session registration: agent, session ID, repository, branch, commit, start time, and the first prompt ID.\n- Work locations: the repository and branch of each Git working tree the session works in. Paths are not sent.\n- Config snapshot: the structure of the configuration in use (Claude Code only).\n- OTel telemetry: what the user chooses to send.\n- For work on an Issue, `record-run` registers the session as a Run and closes it. It records no Plan, Decision, or Definition of Done.\n\n## What is not collected\n\n- Prompts, responses, tool input and output, and the body of code diffs arrive only when the user sends them (`--send-content` or managed settings) and the Workspace stores that category. The members the Workspace chooses can read them. `harnessforce import` never sends them.\n- Never put these contents, secrets, or environment variable values in MCP tool input or in a record.\n\n## Which hook sends what\n\n- SessionStart: session registration and the config snapshot (Codex sends session registration only).\n- UserPromptSubmit: resends on the first prompt (Claude Code only).\n- Stop: sends the work locations at the end of a turn in which they changed.\n- A failing hook never stops the session. When the hook cannot send, it shows a one-line warning. Tell the user when a warning appears.\n\n## Which skill and tool to use, and when\n\n- For work on a specified Issue ID, or when the environment variable `HARNESSFORCE_ISSUE` is set, follow `record-run` and use `start_run`, `get_issue`, and `complete_run`. An agent that cannot load the skill calls the tools in the same order.\n- Pass the value of the `harnessforce session_id:` line in the context to `start_run`. If there are several, use the last one. If the line is missing, do not guess the session ID, and do not call `start_run` or `complete_run`.\n- Use `propose-improvements` for the analysis of `/harnessforce:tune`.\n- When no Issue is specified, do not start recording a Run on your own. For work that commits changes, follow \"When no Issue is specified\" in `record-run` and ask the user once whether to link it to an existing Issue.\n\n## Red Flags\n\nStop when one of these thoughts comes up.\n\n| Thought | Reality |\n| --- | --- |\n| An Issue was specified, but the work is small, so recording is unnecessary | Work on a specified Issue is recorded regardless of its size |\n| The session ID line is missing, so I will guess it and call `start_run` | Do not guess. The Run would no longer be linked to the session |\n| Summarizing the content before recording would help | Do not pass content to the tool. It goes beyond what is collected |\n| A warning appeared, but I can ignore it | Sending is not working. Tell the user |\n\n## Priority\n\n1. The user's instructions (CLAUDE.md, AGENTS.md, direct requests). If the user tells you to stop recording, stop recording the Run.\n2. This introduction.\n3. Default behavior.\n\n## Subagents\n\nA subagent that was delegated only a specific task by its parent does not register a Run by following this introduction. The parent registers the Run.\n".replace(/\r\n/g, "\n").replace(/^---\n[\s\S]*?\n---\n+/, "").trimEnd();
 // ../agent-core/src/session-context.ts
 const sessionContextLine = (sessionId) => `harnessforce session_id: ${sessionId}`;
 const sessionContext = (sessionId) => ({ hookSpecificOutput: {
@@ -10151,7 +10596,10 @@ function finishInit(issued, args, deps, result) {
 async function openKeychain(deps, previousWorkspaceId) {
 	return await deps.keychain.openForInit({
 		previousWorkspaceId,
-		onWaiting: () => deps.stderr(`${INIT_MESSAGES.waitingForSecretService}\n`)
+		onWaiting: (provider) => {
+			deps.stderr(`${INIT_MESSAGES.waitingForSecretService}\n`);
+			if (provider?.isKWallet) deps.stderr(`${kwalletUnlockHint(provider.walletLabel)}\n`);
+		}
 	}).catch(() => stop$1("keychainUnavailable")) ?? stopWith(keychainUnavailableMessage(deps.keychain));
 }
 function revokeHashes({ items }) {
@@ -13706,7 +14154,12 @@ process.exitCode = relaunched ?? await run(argv, {
 		load: () => import("@napi-rs/keyring"),
 		secretService: createSecretServiceProcess({
 			execPath: process.execPath,
-			resolveKeyring: () => require.resolve("@napi-rs/keyring")
+			resolveKeyring: () => require.resolve("@napi-rs/keyring"),
+			lock: createSecretServiceLock({
+				address: sessionBusAddress(process.env),
+				uid: process.getuid?.() ?? 0,
+				readComm: (pid) => readFile(`/proc/${pid}/comm`, "utf8")
+			})
 		})
 	}),
 	stdout: (text) => process.stdout.write(text),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harnessforce/cli",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Harnessforce command line (harnessforce)",
   "keywords": [
     "harnessforce",