@webinson/peer-core 0.0.0-stage → 0.1.894

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 T3 Tools Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# @webinson/peer-core
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Peer's coordination for coding agents on a computer without the Peer app: the `peer` command.
+
+```sh
+npm i -g @webinson/peer-core        # or: npx @webinson/peer-core core status
+peer core login you@company.com   # a code is mailed by your Peer Hub
+peer core share ~/code/project    # the folder needs a git remote
+peer core connect cursor          # Cursor, VS Code, Windsurf, Gemini CLI, OpenCode, Zed, Copilot CLI, Kiro
+peer core hooks install           # Claude Code (and Codex with --codex)
+peer core serve --detach          # or let the editor start it on demand
+```
+
+`peer core status` says who runs Peer here; `peer core stop` stops Peer Core. The Peer desktop app,
+when it starts, takes coordination over. Any other `peer <command>` goes to the running Peer.
+
+Version 0.1.894 of Peer Local (https://github.com/SemanS/peer-app, branch `peer`), based on T3 Code.

package/dist/AcpMcpStdioBridge-ZWAIz2dT.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+import { $t as runPromise, Cn as tryPromise, I as fail, Mn as void_, f as asVoid, g as catchCause, mn as sync, o as andThen, st as gen, tt as forkChild, va as squash } from "./Effect-DXlc4A9S.mjs";
+import { Bn as await_, O as fromAsyncIterable, lt as runCollect, n as responsePayloads, pt as runForEach, t as discardResponseBody, zn as awaitAll } from "./mcpResponsePayloads-Be_jYC4_.mjs";
+import * as NodeReadline from "node:readline";
+//#region src/mcp/AcpMcpStdioBridge.ts
+/**
+* ACP agents must support stdio MCP servers, while optional http/sse support is
+* unevenly implemented.
+*/
+var AcpMcpBridgeError = class extends Error {
+	_tag = "AcpMcpBridgeError";
+};
+const bridgeError = (cause) => cause instanceof AcpMcpBridgeError ? cause : new AcpMcpBridgeError(cause instanceof Error ? cause.message : String(cause), { cause });
+const MCP_PROTOCOL_VERSION = "2025-06-18";
+function asEnvelope(value) {
+	return typeof value === "object" && value !== null ? value : null;
+}
+function protocolVersionOf(entry) {
+	const result = asEnvelope(entry)?.result;
+	const version = typeof result === "object" && result !== null ? result.protocolVersion : void 0;
+	return typeof version === "string" && version.length > 0 ? version : null;
+}
+/**
+* This is the terminal fallback for ACP agents that accept `mcpServers` in
+* `session/new` but fail to expose those tools to their model. Compliant ACP
+* agents continue to use the stdio bridge above.
+*/
+function callAcpMcpTool(options) {
+	const fetchImplementation = options.fetchImplementation ?? fetch;
+	return gen(function* () {
+		let sessionId = null;
+		let protocolVersion = null;
+		const send = (message) => gen(function* () {
+			const response = yield* tryPromise({
+				try: () => fetchImplementation(options.endpoint, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						accept: "application/json, text/event-stream",
+						authorization: options.authorization,
+						...sessionId === null ? {} : { "mcp-session-id": sessionId },
+						...protocolVersion === null ? {} : { "mcp-protocol-version": protocolVersion }
+					},
+					body: JSON.stringify(message)
+				}),
+				catch: bridgeError
+			});
+			sessionId = response.headers.get("mcp-session-id") ?? sessionId;
+			if (!response.ok) {
+				yield* discardResponseBody(response);
+				return yield* fail(new AcpMcpBridgeError(`T3 Code MCP endpoint responded with HTTP ${response.status}.`));
+			}
+			const payloads = yield* runCollect(responsePayloads(response, bridgeError));
+			for (const payload of payloads) protocolVersion = protocolVersionOf(payload) ?? protocolVersion;
+			return payloads;
+		});
+		const initializeId = "t3-acp-cli-initialize";
+		const initializeResponse = (yield* send({
+			jsonrpc: "2.0",
+			id: initializeId,
+			method: "initialize",
+			params: {
+				protocolVersion: MCP_PROTOCOL_VERSION,
+				capabilities: {},
+				clientInfo: {
+					name: "t3-code-acp-cli",
+					version: "0.0.0"
+				}
+			}
+		})).find((entry) => asEnvelope(entry)?.id === initializeId);
+		if (initializeResponse === void 0 || asEnvelope(initializeResponse)?.error !== void 0) return yield* fail(new AcpMcpBridgeError("T3 Code MCP endpoint rejected initialization."));
+		yield* send({
+			jsonrpc: "2.0",
+			method: "notifications/initialized"
+		});
+		const callId = "t3-acp-cli-tool-call";
+		const envelope = asEnvelope((yield* send({
+			jsonrpc: "2.0",
+			id: callId,
+			method: "tools/call",
+			params: {
+				name: options.tool,
+				arguments: options.arguments
+			}
+		})).find((entry) => asEnvelope(entry)?.id === callId));
+		if (envelope === null || envelope.error !== void 0) return yield* fail(new AcpMcpBridgeError(`T3 Code MCP tool call failed${envelope?.error === void 0 ? "." : `: ${JSON.stringify(envelope.error)}`}`));
+		return envelope.result;
+	});
+}
+function runAcpMcpStdioBridge(options) {
+	const fetchImplementation = options.fetchImplementation ?? fetch;
+	return gen(function* () {
+		let sessionId = null;
+		let protocolVersion = null;
+		const running = /* @__PURE__ */ new Set();
+		const writeMessage = (message) => sync(() => {
+			options.output.write(`${JSON.stringify(message)}\n`);
+		});
+		const handleServerPayload = (payload) => gen(function* () {
+			for (const entry of Array.isArray(payload) ? payload : [payload]) {
+				protocolVersion = protocolVersionOf(entry) ?? protocolVersion;
+				yield* writeMessage(entry);
+			}
+		});
+		const respondWithError = (requestId, message, code = -32603) => writeMessage({
+			jsonrpc: "2.0",
+			id: requestId ?? null,
+			error: {
+				code,
+				message
+			}
+		});
+		const forward = (line, envelope) => gen(function* () {
+			const response = yield* tryPromise({
+				try: () => fetchImplementation(options.endpoint, {
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+						accept: "application/json, text/event-stream",
+						authorization: options.authorization,
+						...sessionId === null ? {} : { "mcp-session-id": sessionId },
+						...protocolVersion === null ? {} : { "mcp-protocol-version": protocolVersion }
+					},
+					body: line
+				}),
+				catch: bridgeError
+			});
+			sessionId = response.headers.get("mcp-session-id") ?? sessionId;
+			if (!response.ok) {
+				if (envelope.id !== void 0) yield* respondWithError(envelope.id, `T3 Code MCP endpoint responded with HTTP ${response.status}.`);
+				return yield* discardResponseBody(response);
+			}
+			yield* runForEach(responsePayloads(response, bridgeError), handleServerPayload);
+		}).pipe(catchCause((cause) => {
+			if (envelope.id === void 0) return void_;
+			const error = squash(cause);
+			return respondWithError(envelope.id, `T3 Code MCP bridge request failed: ${error instanceof Error ? error.message : String(error)}`);
+		}));
+		let sessionBarrier = void_;
+		let sessionBarrierPending = false;
+		const launch = (task) => gen(function* () {
+			const fiber = yield* forkChild(task);
+			running.add(fiber);
+			yield* forkChild(await_(fiber).pipe(andThen(sync(() => {
+				running.delete(fiber);
+			}))));
+		});
+		const dispatch = (line) => gen(function* () {
+			if (line.trim().length === 0) return;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				return yield* respondWithError(null, "Parse error", -32700);
+			}
+			const envelope = asEnvelope(parsed);
+			if (envelope === null) return;
+			const isResponse = envelope.id !== void 0 && ("result" in envelope || "error" in envelope);
+			const isSessionHandshake = envelope.method === "initialize" || envelope.method === "notifications/initialized";
+			if (isResponse) return yield* launch(forward(line, envelope));
+			if (isSessionHandshake) {
+				const fiber = yield* forkChild(sessionBarrier.pipe(andThen(forward(line, envelope))));
+				running.add(fiber);
+				const barrier = await_(fiber).pipe(asVoid);
+				sessionBarrier = barrier;
+				sessionBarrierPending = true;
+				yield* forkChild(await_(fiber).pipe(andThen(sync(() => {
+					running.delete(fiber);
+					if (sessionBarrier === barrier) sessionBarrierPending = false;
+				}))));
+				return;
+			}
+			const task = sessionBarrierPending ? sessionBarrier.pipe(andThen(forward(line, envelope))) : forward(line, envelope);
+			return yield* launch(task);
+		});
+		const reader = NodeReadline.createInterface({ input: options.input });
+		yield* runForEach(fromAsyncIterable(reader, bridgeError), dispatch).pipe(catchCause(() => void_));
+		yield* awaitAll(running);
+	});
+}
+/**
+* Kept free of heavy imports: these commands run on the ACP first-message
+* critical path.
+*/
+async function runAcpMcpCliFastPath(command, args) {
+	const endpoint = process.env.T3_ACP_MCP_ENDPOINT;
+	const authorization = process.env.T3_ACP_MCP_AUTHORIZATION;
+	if (endpoint === void 0 || authorization === void 0) {
+		process.stderr.write(`${command} requires T3_ACP_MCP_ENDPOINT and T3_ACP_MCP_AUTHORIZATION.\n`);
+		process.exitCode = 2;
+		return;
+	}
+	if (command === "acp-mcp-bridge") {
+		await runPromise(runAcpMcpStdioBridge({
+			endpoint,
+			authorization,
+			input: process.stdin,
+			output: process.stdout
+		}));
+		return;
+	}
+	const [tool, argumentsJson] = args;
+	if (tool === void 0 || argumentsJson === void 0) {
+		process.stderr.write("acp-mcp-call requires <tool> and <arguments-json>.\n");
+		process.exitCode = 2;
+		return;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(argumentsJson);
+	} catch {
+		process.stderr.write("acp-mcp-call arguments must be valid JSON.\n");
+		process.exitCode = 2;
+		return;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+		process.stderr.write("acp-mcp-call arguments must be a JSON object.\n");
+		process.exitCode = 2;
+		return;
+	}
+	const result = await runPromise(callAcpMcpTool({
+		endpoint,
+		authorization,
+		tool,
+		arguments: parsed
+	}));
+	process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+//#endregion
+export { runAcpMcpStdioBridge as i, callAcpMcpTool as n, runAcpMcpCliFastPath as r, AcpMcpBridgeError as t };
+
+//# sourceMappingURL=AcpMcpStdioBridge-ZWAIz2dT.mjs.map

package/dist/AcpMcpStdioBridge-up0MRqDk.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+export { r as runAcpMcpCliFastPath } from "./AcpMcpStdioBridge-ZWAIz2dT.mjs";

package/dist/Clock-B88OfuDl.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+import { Ma as currentTimeNanos$1, Oa as clockWith$1, co as monotonicTimeNanos$1, ja as currentTimeMillis$1, ya as ClockRef } from "./Effect-DXlc4A9S.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Clock.js
+/**
+* Context reference for the active time service in the environment.
+*
+* **When to use**
+*
+* Use when you need to access or provide the full time service, including sleep
+* operations, rather than a single timestamp accessor.
+*
+* **Example** (Accessing the Clock service)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* const program = Effect.gen(function*() {
+*   const clock = yield* Clock.Clock
+*   return clock.currentTimeMillisUnsafe()
+* })
+*
+* await Effect.runPromise(Effect.provideService(program, Clock.Clock, testClock)) // => 1_000
+* ```
+*
+* @see {@link clockWith} for using the current Clock service inside an effect
+* @see {@link currentTimeMillis} for reading the current time in milliseconds
+* @see {@link currentTimeNanos} for reading the current time in nanoseconds
+*
+* @stability stable
+* @category services
+* @since 2.0.0
+*/
+const Clock = ClockRef;
+/**
+* Accesses the current Clock service and uses it to run the provided function.
+*
+* **When to use**
+*
+* Use when you need the full Clock service interface to perform multiple time
+* operations or call unsafe variants within a single effect.
+*
+* **Example** (Accessing the current Clock service)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* const program = Clock.clockWith((clock) => Effect.sync(() => clock.currentTimeMillisUnsafe()))
+*
+* await Effect.runPromise(Effect.provideService(program, Clock.Clock, testClock)) // => 1_000
+* ```
+*
+* @see {@link Clock} for the service reference
+* @see {@link currentTimeMillis} for convenience accessor that returns milliseconds
+* @see {@link currentTimeNanos} for convenience accessor that returns nanoseconds
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const clockWith = clockWith$1;
+/**
+* Returns an Effect that succeeds with the current Unix time in milliseconds.
+*
+* **When to use**
+*
+* Use to create wall-clock timestamps from the active `Clock` service with
+* millisecond precision.
+*
+* **Gotchas**
+*
+* The value can move backward or forward when the system wall clock is
+* corrected, so it is not suitable for measuring elapsed time.
+*
+* **Example** (Reading milliseconds)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* await Effect.runPromise(Effect.provideService(Clock.currentTimeMillis, Clock.Clock, testClock)) // => 1_000
+* ```
+*
+* @see {@link currentTimeNanos} for nanosecond precision
+* @see {@link monotonicTimeNanos} for measuring elapsed time
+* @see {@link clockWith} for accessing the full Clock service
+*
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const currentTimeMillis = currentTimeMillis$1;
+/**
+* Returns an Effect that succeeds with the current Unix time in nanoseconds.
+*
+* **When to use**
+*
+* Use to create wall-clock timestamps from the active `Clock` service with
+* nanosecond precision.
+*
+* **Gotchas**
+*
+* The value can move backward or forward when the system wall clock is
+* corrected, so it is not suitable for measuring elapsed time.
+* The live clock allows up to one second of drift from `Date.now()` before
+* re-anchoring.
+*
+* **Example** (Reading nanoseconds)
+*
+* ```ts import.meta.vitest
+* import { Clock, Effect } from "effect"
+*
+* const testClock: Clock.Clock = {
+*   currentTimeMillisUnsafe: () => 1_000,
+*   currentTimeMillis: Effect.succeed(1_000),
+*   monotonicTimeNanosUnsafe: () => 1_000_000_000n,
+*   monotonicTimeNanos: Effect.succeed(1_000_000_000n),
+*   currentTimeNanosUnsafe: () => 1_000_000_000n,
+*   currentTimeNanos: Effect.succeed(1_000_000_000n),
+*   sleep: () => Effect.void
+* }
+*
+* await Effect.runPromise(Effect.provideService(Clock.currentTimeNanos, Clock.Clock, testClock)) // => 1_000_000_000n
+* ```
+*
+* @see {@link monotonicTimeNanos} for measuring elapsed time
+*
+* @stability stable
+* @category accessors
+* @since 2.0.0
+*/
+const currentTimeNanos = currentTimeNanos$1;
+/**
+* Returns an Effect that succeeds with the current monotonic time in
+* nanoseconds.
+*
+* **When to use**
+*
+* Use to measure elapsed time by subtracting two readings.
+*
+* **Gotchas**
+*
+* The value has an arbitrary origin and is unsuitable for serialization. Use
+* it only to subtract readings produced by the same clock. Whether it advances
+* while the host is suspended depends on the runtime.
+*
+* @see {@link currentTimeNanos} for Unix wall-clock timestamps
+*
+* @stability stable
+* @category accessors
+* @since 4.0.0
+*/
+const monotonicTimeNanos = monotonicTimeNanos$1;
+//#endregion
+export { monotonicTimeNanos as a, currentTimeNanos as i, clockWith as n, currentTimeMillis as r, Clock as t };
+
+//# sourceMappingURL=Clock-B88OfuDl.mjs.map