claude-use 14.3.0 → 14.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli.cjs CHANGED
@@ -44252,13 +44252,14 @@ async function teleportRcSession(deps, sessionId, marker) {
44252
44252
  function buildRcMarkReadBody(eventId) {
44253
44253
  return eventId === void 0 ? {} : { event_id: eventId };
44254
44254
  }
44255
- var RC_PERMISSION_MODES, RC_CONTEXT_USAGE_DETAILS, RC_READ_FILE_ENCODINGS;
44255
+ var RC_SEND_DELIVERY_NOTE, RC_PERMISSION_MODES, RC_CONTEXT_USAGE_DETAILS, RC_READ_FILE_ENCODINGS;
44256
44256
  var init_rcWrites = __esm({
44257
44257
  "src/frontdoor/rcWrites.ts"() {
44258
44258
  "use strict";
44259
44259
  init_http();
44260
44260
  init_rcSessions();
44261
44261
  init_rcQuestions();
44262
+ RC_SEND_DELIVERY_NOTE = "Claude Code reads it as a message from another session, not as a person typing in an attached client, because the service stamps it with the session's own client platform. Whether it reaches the model is the receiving session's crossSessionInbound setting: with none set, a session that bypasses permission prompts holds it for approval, since the write cannot attest a permission mode.";
44262
44263
  RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
44263
44264
  RC_CONTEXT_USAGE_DETAILS = ["summary", "full"];
44264
44265
  RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
@@ -74941,7 +74942,7 @@ var init_package = __esm({
74941
74942
  "package.json"() {
74942
74943
  package_default = {
74943
74944
  name: "claude-use",
74944
- version: "14.3.0",
74945
+ version: "14.3.1",
74945
74946
  description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
74946
74947
  license: "MIT",
74947
74948
  author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -144350,7 +144351,7 @@ function createRcApiRouter(deps) {
144350
144351
  const dropped = statuses.flatMap((status) => status.pendingDropped === void 0 ? [] : [{ sessionId: status.id, count: status.pendingDropped }]);
144351
144352
  return { pending, ...dropped.length === 0 ? {} : { dropped } };
144352
144353
  }),
144353
- send: authed.meta(openapi({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", tags: [RC_API_TAG] })).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.inject(input2.session, input2.text)) })),
144354
+ send: authed.meta(openapi({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", description: RC_SEND_DELIVERY_NOTE, tags: [RC_API_TAG] })).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.inject(input2.session, input2.text)) })),
144354
144355
  answer: authed.meta(openapi({ method: "POST", path: "/rest/rc/answer", summary: "Answer one pending control request: approve or deny it, or choose the options of a pending question", tags: [RC_API_TAG] })).input(RcAnswerInputSchema).output(RcAnswerOutputSchema).handler(async ({ input: input2 }) => {
144355
144356
  const decision = { approve: input2.approve, message: input2.approve || input2.text === void 0 ? void 0 : input2.text, ...input2.choices === void 0 ? {} : { choices: input2.choices } };
144356
144357
  return { session: input2.session, request: input2.request, sequenceNums: delivered(input2.session, await deps.answer(input2.session, input2.request, decision)) };
@@ -150995,7 +150996,7 @@ function registerRcCommand(frontdoor, paths) {
150995
150996
  ["agent-shim frontdoor rc pending", "agent-shim frontdoor rc pending --json"]
150996
150997
  );
150997
150998
  withExamples(
150998
- rc2.command("send").description("Send a text prompt into one observed Remote Control session, arriving as a message from an attached client would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--text <text>", "The prompt text to deliver.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
150999
+ rc2.command("send").description(`Write a text prompt into one observed Remote Control session's event stream. ${RC_SEND_DELIVERY_NOTE} The printed sequence numbers confirm the service filed the write, not that the model received it.`).requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--text <text>", "The prompt text to write.").option("--json", "Print the write result as JSON.").action(async (options) => {
150999
151000
  const result = await frontDoorRcControlFromState(realFarmFs, paths).sendPrompt(options.session, options.text);
151000
151001
  if (!result.ok) {
151001
151002
  throw new Error(result.message);
package/dist/index.cjs CHANGED
@@ -7606,13 +7606,14 @@ async function teleportRcSession(deps, sessionId, marker) {
7606
7606
  function buildRcMarkReadBody(eventId) {
7607
7607
  return eventId === void 0 ? {} : { event_id: eventId };
7608
7608
  }
7609
- var RC_PERMISSION_MODES, RC_CONTEXT_USAGE_DETAILS, RC_READ_FILE_ENCODINGS;
7609
+ var RC_SEND_DELIVERY_NOTE, RC_PERMISSION_MODES, RC_CONTEXT_USAGE_DETAILS, RC_READ_FILE_ENCODINGS;
7610
7610
  var init_rcWrites = __esm({
7611
7611
  "src/frontdoor/rcWrites.ts"() {
7612
7612
  "use strict";
7613
7613
  init_http();
7614
7614
  init_rcSessions();
7615
7615
  init_rcQuestions();
7616
+ RC_SEND_DELIVERY_NOTE = "Claude Code reads it as a message from another session, not as a person typing in an attached client, because the service stamps it with the session's own client platform. Whether it reaches the model is the receiving session's crossSessionInbound setting: with none set, a session that bypasses permission prompts holds it for approval, since the write cannot attest a permission mode.";
7616
7617
  RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
7617
7618
  RC_CONTEXT_USAGE_DETAILS = ["summary", "full"];
7618
7619
  RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
@@ -14108,7 +14109,7 @@ var init_package = __esm({
14108
14109
  "package.json"() {
14109
14110
  package_default = {
14110
14111
  name: "claude-use",
14111
- version: "14.3.0",
14112
+ version: "14.3.1",
14112
14113
  description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
14113
14114
  license: "MIT",
14114
14115
  author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -20399,7 +20400,7 @@ function createRcApiRouter(deps) {
20399
20400
  const dropped = statuses.flatMap((status) => status.pendingDropped === void 0 ? [] : [{ sessionId: status.id, count: status.pendingDropped }]);
20400
20401
  return { pending, ...dropped.length === 0 ? {} : { dropped } };
20401
20402
  }),
20402
- send: authed.meta((0, import_openapi.openapi)({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", tags: [RC_API_TAG] })).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.inject(input.session, input.text)) })),
20403
+ send: authed.meta((0, import_openapi.openapi)({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", description: RC_SEND_DELIVERY_NOTE, tags: [RC_API_TAG] })).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.inject(input.session, input.text)) })),
20403
20404
  answer: authed.meta((0, import_openapi.openapi)({ method: "POST", path: "/rest/rc/answer", summary: "Answer one pending control request: approve or deny it, or choose the options of a pending question", tags: [RC_API_TAG] })).input(RcAnswerInputSchema).output(RcAnswerOutputSchema).handler(async ({ input }) => {
20404
20405
  const decision = { approve: input.approve, message: input.approve || input.text === void 0 ? void 0 : input.text, ...input.choices === void 0 ? {} : { choices: input.choices } };
20405
20406
  return { session: input.session, request: input.request, sequenceNums: delivered(input.session, await deps.answer(input.session, input.request, decision)) };
package/dist/index.mjs CHANGED
@@ -7581,13 +7581,14 @@ async function teleportRcSession(deps, sessionId, marker) {
7581
7581
  function buildRcMarkReadBody(eventId) {
7582
7582
  return eventId === void 0 ? {} : { event_id: eventId };
7583
7583
  }
7584
- var RC_PERMISSION_MODES, RC_CONTEXT_USAGE_DETAILS, RC_READ_FILE_ENCODINGS;
7584
+ var RC_SEND_DELIVERY_NOTE, RC_PERMISSION_MODES, RC_CONTEXT_USAGE_DETAILS, RC_READ_FILE_ENCODINGS;
7585
7585
  var init_rcWrites = __esm({
7586
7586
  "src/frontdoor/rcWrites.ts"() {
7587
7587
  "use strict";
7588
7588
  init_http();
7589
7589
  init_rcSessions();
7590
7590
  init_rcQuestions();
7591
+ RC_SEND_DELIVERY_NOTE = "Claude Code reads it as a message from another session, not as a person typing in an attached client, because the service stamps it with the session's own client platform. Whether it reaches the model is the receiving session's crossSessionInbound setting: with none set, a session that bypasses permission prompts holds it for approval, since the write cannot attest a permission mode.";
7591
7592
  RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
7592
7593
  RC_CONTEXT_USAGE_DETAILS = ["summary", "full"];
7593
7594
  RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
@@ -14081,7 +14082,7 @@ var init_package = __esm({
14081
14082
  "package.json"() {
14082
14083
  package_default = {
14083
14084
  name: "claude-use",
14084
- version: "14.3.0",
14085
+ version: "14.3.1",
14085
14086
  description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
14086
14087
  license: "MIT",
14087
14088
  author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -19948,7 +19949,7 @@ function createRcApiRouter(deps) {
19948
19949
  const dropped = statuses.flatMap((status) => status.pendingDropped === void 0 ? [] : [{ sessionId: status.id, count: status.pendingDropped }]);
19949
19950
  return { pending, ...dropped.length === 0 ? {} : { dropped } };
19950
19951
  }),
19951
- send: authed.meta(openapi({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", tags: [RC_API_TAG] })).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.inject(input.session, input.text)) })),
19952
+ send: authed.meta(openapi({ method: "POST", path: "/rest/rc/send", summary: "Send one message into a session", description: RC_SEND_DELIVERY_NOTE, tags: [RC_API_TAG] })).input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.inject(input.session, input.text)) })),
19952
19953
  answer: authed.meta(openapi({ method: "POST", path: "/rest/rc/answer", summary: "Answer one pending control request: approve or deny it, or choose the options of a pending question", tags: [RC_API_TAG] })).input(RcAnswerInputSchema).output(RcAnswerOutputSchema).handler(async ({ input }) => {
19953
19954
  const decision = { approve: input.approve, message: input.approve || input.text === void 0 ? void 0 : input.text, ...input.choices === void 0 ? {} : { choices: input.choices } };
19954
19955
  return { session: input.session, request: input.request, sequenceNums: delivered(input.session, await deps.answer(input.session, input.request, decision)) };
@@ -7526,16 +7526,7 @@ declare function observingRoutedRoute(route: FrontDoorRoute, tracker: RcSessionT
7526
7526
  declare function rcObserverAsPassthrough(observer: RcExchangeObserver): PassthroughObserver;
7527
7527
 
7528
7528
  /**
7529
- * The Remote Control client-half writes: the payload builders, the write engine and one typed operation per control verb the door can send into an observed session, every one an event write to `/v1/code/sessions/{id}/events` over the door's interception-proof dials, authenticated by the observed bearer and protocol headers the tracker (`rcSessions.ts`) holds.
7530
- *
7531
- * Every request-shaped write goes through one envelope builder (`buildRcControlRequestPayload`) so the family cannot drift apart in shape, and one delivery engine (`deliverRcClientPayload`, module-local) so the two credential guards, the dial and the sequence-cursor advance exist exactly once. The fields each subtype carries are the SDK's own (`@anthropic-ai/claude-agent-sdk` `sdk.d.ts`) where it declares the subtype, and the CLI bundle's own request builders where it does not (`mcp_authenticate`, `mcp_oauth_callback_url`), each named in its builder's doc comment.
7532
- *
7533
- * A write that carried a `control_request` returns the request id it minted, because the worker's `control_response` echoes exactly that id on the stream the door already fans out: a consumer that wants the answer matches it there, and the id is surfaced by the result since only the door ever knew it.
7534
- *
7535
- * Two writes stand outside the events path: the teleport marker, whose channel is the session's teleport-events path (the one write the family addresses elsewhere, and the one the CLI only ever reads), and the read receipt, which is not a payload write at all but the mark_read endpoint's own small body, built here so every surface the door serves it from posts the same shape.
7536
- */
7537
- /**
7538
- * Builds the user-message payload event for one injected prompt: the Agent SDK stream-json `user` message shape (`type`, `uuid`, `session_id`, `parent_tool_use_id`, `message` with a `user` role), the same envelope a claude.ai client sends as a turn. The content is the plain string form, which is the shape validated end to end against the real API by the third-party client survey that settled this protocol.
7529
+ * Builds the user-message payload event for one injected prompt: the Agent SDK stream-json `user` message shape (`type`, `uuid`, `session_id`, `parent_tool_use_id`, `message` with a `user` role), the envelope a claude.ai client sends as a turn. The envelope alone does not decide how the worker reads it: the service adds the writer's `client_platform`, and that is what makes a client's turn a person's and the door's a peer's (`RC_SEND_DELIVERY_NOTE`). The content is the plain string form, which is the shape validated end to end against the real API by the third-party client survey that settled this protocol.
7539
7530
  */
7540
7531
  declare function buildRcUserMessagePayload(uuid: string, sessionId: string, text: string): Record<string, unknown>;
7541
7532
  /** Wraps payload event(s) in the write body the endpoint takes: `{"events": [{"payload": {...}}]}`. */
@@ -7586,7 +7577,7 @@ interface RcInjectDeps {
7586
7577
  readonly newUuid: () => string;
7587
7578
  }
7588
7579
  /**
7589
- * Injects one user-message prompt into an observed session: the documented client-half write, `POST /v1/code/sessions/{id}/events`, authenticated by the observed bearer and carrying the observed protocol headers, the observed `anthropic-client-platform` included, so the door never names an app it is not. The result is the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
7580
+ * Injects one user-message prompt into an observed session: the documented client-half write, `POST /v1/code/sessions/{id}/events`, authenticated by the observed bearer and carrying the observed protocol headers, the observed `anthropic-client-platform` included, so the door never names an app it is not. The result is the sequence numbers the real service assigned, or a verbose failure: an assigned number confirms the service filed the event, not that the session's model received it, since the worker reads it as a peer message and its own inbound setting decides whether to deliver, hold or drop it (`RC_SEND_DELIVERY_NOTE`). A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
7590
7581
  */
7591
7582
  declare function injectRcUserMessage(deps: RcInjectDeps, sessionId: string, text: string): Promise<RcEventWriteResult>;
7592
7583
  /** The decision an answer carries: approve or deny, with the message a denial shows the worker (the protocol's allow result has no text field, so an approval carries none), and for a question the options chosen. */
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "claude-use",
3
- "version": "14.3.0",
3
+ "version": "14.3.1",
4
4
  "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
5
5
  "license": "MIT",
6
6
  "author": "Joseph Mearman <joseph@mearman.co.uk>",