claudish 14.15.1 → 14.16.0

package/dist/index.js

@@ -5491,7 +5491,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "14.15.1";
+var VERSION = "14.16.0";
 
 // src/redact.ts
 function isPlaceholder(value) {
@@ -49347,10 +49347,11 @@ var init_devin_request = __esm(() => {
 function unaryMetadata(apiKey) {
   return msg(bytes(1, "chisel"), bytes(2, DEVIN_CLI_VERSION), bytes(3, apiKey), bytes(4, "en"), bytes(5, process.platform), bytes(7, DEVIN_CLI_VERSION));
 }
-async function postUnary(path, apiKey) {
+async function postDevinUnaryRaw(path, apiKey, opts = {}) {
   const url = `${readDevinServerUrl()}${path}`;
+  let response;
   try {
-    const response = await fetch(url, {
+    response = await fetch(url, {
       method: "POST",
       headers: {
         authorization: `Basic ${apiKey}-${apiKey}`,
@@ -49358,17 +49359,38 @@ async function postUnary(path, apiKey) {
         "connect-protocol-version": "1"
       },
       body: msg(bytes(1, unaryMetadata(apiKey))),
-      signal: AbortSignal.timeout(UNARY_TIMEOUT_MS)
+      signal: opts.signal
     });
-    if (!response.ok) {
-      log(`[Devin] ${path} failed: HTTP ${response.status}`);
-      return null;
-    }
-    return new Uint8Array(await response.arrayBuffer());
-  } catch (err) {
-    log(`[Devin] ${path} error: ${err}`);
+  } catch (error) {
+    return { kind: "unreachable", url, error };
+  }
+  if (!response.ok) {
+    return { kind: "answered", url, status: response.status, body: { kind: "unread" } };
+  }
+  try {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    return { kind: "answered", url, status: response.status, body: { kind: "bytes", bytes } };
+  } catch (error) {
+    return { kind: "answered", url, status: response.status, body: { kind: "read-failed", error } };
+  }
+}
+async function postUnary(path, apiKey) {
+  const raw = await postDevinUnaryRaw(path, apiKey, {
+    signal: AbortSignal.timeout(UNARY_TIMEOUT_MS)
+  });
+  if (raw.kind === "unreachable") {
+    log(`[Devin] ${path} error: ${raw.error}`);
+    return null;
+  }
+  if (raw.status < 200 || raw.status >= 300) {
+    log(`[Devin] ${path} failed: HTTP ${raw.status}`);
+    return null;
+  }
+  if (raw.body.kind === "read-failed") {
+    log(`[Devin] ${path} error: ${raw.body.error}`);
     return null;
   }
+  return raw.body.kind === "bytes" ? raw.body.bytes : null;
 }
 function decodeModelDetails(payload) {
   let maxOutput = 0;
@@ -49496,13 +49518,17 @@ async function fetchDevinAllowedUids(apiKey) {
   const body = await postUnary(TEAM_SETTINGS_PATH, apiKey);
   if (!body)
     return [];
+  const uids = decodeAllowedUids(body);
+  log(`[Devin] GetCliTeamSettings: ${uids.length} allowed uids`);
+  return uids;
+}
+function decodeAllowedUids(body) {
   const uids = [];
   for (const field of topLevelDelimited(body, 7)) {
     const uid = readString(field).trim();
     if (uid)
       uids.push(uid);
   }
-  log(`[Devin] GetCliTeamSettings: ${uids.length} allowed uids`);
   return uids;
 }
 async function getServedDevinModels(opts) {
@@ -53744,6 +53770,7 @@ data: ${JSON.stringify(data)}
             if (frame.flags === FRAME_FLAG_END_OF_STREAM) {
               const raw = new TextDecoder().decode(frame.payload).trim();
               if (!raw || raw === "{}") {
+                opts.onEndOfStream?.();
                 finalize("done");
                 return;
               }
@@ -94280,6 +94307,13 @@ ${h("SUBCOMMANDS")}
                                           Send the file's Gemini request once through the
                                           Antigravity login (generateContent, no retry, model
                                           ${dim("id unchanged); print the raw answer as one JSON line")}
+  ${green("claudish subscription models devin")} ${yellow("--raw --json")}
+                                          Print Devin's decoded GetCliModelConfigs rows and
+                                          ${dim("allowed model uids as one JSON line (for models-index)")}
+  ${green("claudish subscription probe devin")} ${yellow("--model <uid> --request-file <path> --raw --json")}
+                                          Send the file's Anthropic Messages request once through
+                                          the Devin login (GetChatMessage, no retry, uid unchanged);
+                                          ${dim("print the decoded answer as one JSON line")}
   ${green("claudish update")}                        Check for updates and install the latest version
 
   ${bold("Profiles:")}
@@ -110404,6 +110438,94 @@ var init_subscription_antigravity_session = __esm(() => {
   TIMED_OUT = Symbol("timed-out");
 });
 
+// src/subscription-devin-models.ts
+var exports_subscription_devin_models = {};
+__export(exports_subscription_devin_models, {
+  readDevinSecrets: () => readDevinSecrets,
+  runDevinRawModelList: () => runDevinRawModelList
+});
+function readDevinSecrets(secrets) {
+  const apiKey = readDevinApiKey();
+  if (!apiKey)
+    return;
+  addSecret(secrets, apiKey);
+  if (apiKey.startsWith(DEVIN_SESSION_TOKEN_PREFIX)) {
+    addSecret(secrets, apiKey.slice(DEVIN_SESSION_TOKEN_PREFIX.length));
+  }
+  return apiKey;
+}
+async function postBounded(path, apiKey, timeoutMs) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const raw = await postDevinUnaryRaw(path, apiKey, { signal: controller.signal });
+    return { raw, timedOut: controller.signal.aborted };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function determineDevin(deps, secrets, facts) {
+  const apiKey = readDevinSecrets(secrets);
+  if (!apiKey) {
+    return modelListFail(facts, modelListFailureOf("credential_missing", "devin_credential_absent"));
+  }
+  const configsCall = await postBounded(MODEL_CONFIGS_PATH, apiKey, deps.httpTimeoutMs);
+  facts.sourceUrl = stripUserinfo(configsCall.raw.url);
+  facts.clientVersion = DEVIN_CLI_VERSION;
+  const configsNetwork = configsCall.timedOut ? "model_configs_timeout" : "model_configs_network_error";
+  if (configsCall.raw.kind === "unreachable") {
+    return modelListFail(facts, modelListFailureOf("network", configsNetwork));
+  }
+  facts.fetchedAt = new Date(deps.now()).toISOString();
+  facts.httpStatus = configsCall.raw.status;
+  if (configsCall.raw.status < 200 || configsCall.raw.status >= 300) {
+    return { envelope: buildModelListEnvelope(facts), exitCode: EXIT.ok };
+  }
+  if (configsCall.raw.body.kind !== "bytes") {
+    return modelListFail(facts, modelListFailureOf("network", configsNetwork, configsCall.raw.status));
+  }
+  const configs = decodeModelConfigs(configsCall.raw.body.bytes);
+  if (configs.length === 0) {
+    return modelListFail(facts, modelListFailureOf("list_incomplete", "configs_empty", configsCall.raw.status));
+  }
+  const teamCall = await postBounded(TEAM_SETTINGS_PATH, apiKey, deps.httpTimeoutMs);
+  facts.teamSettingsUrl = stripUserinfo(teamCall.raw.url);
+  const teamNetwork = teamCall.timedOut ? "team_settings_timeout" : "team_settings_network_error";
+  if (teamCall.raw.kind === "unreachable") {
+    return modelListFail(facts, modelListFailureOf("network", teamNetwork));
+  }
+  facts.teamSettingsHttpStatus = teamCall.raw.status;
+  if (teamCall.raw.status < 200 || teamCall.raw.status >= 300) {
+    return modelListFail(facts, modelListFailureOf("list_incomplete", "team_settings_http_error", teamCall.raw.status));
+  }
+  if (teamCall.raw.body.kind !== "bytes") {
+    return modelListFail(facts, modelListFailureOf("network", teamNetwork, teamCall.raw.status));
+  }
+  const allowedModelUids = decodeAllowedUids(teamCall.raw.body.bytes);
+  if (allowedModelUids.length === 0) {
+    return modelListFail(facts, modelListFailureOf("list_incomplete", "allowed_uids_empty", teamCall.raw.status));
+  }
+  const body = JSON.stringify({ configs, allowedModelUids });
+  return {
+    envelope: buildModelListEnvelope(facts, undefined, body),
+    exitCode: EXIT.ok,
+    bodyText: body
+  };
+}
+async function runDevinRawModelList(deps) {
+  const secrets = newSecrets();
+  const facts = { provider: "devin", tokenRefreshed: false };
+  return runModelListWith(deps, facts, secrets, () => determineDevin(deps, secrets, facts));
+}
+var DEVIN_SESSION_TOKEN_PREFIX = "devin-session-token$";
+var init_subscription_devin_models = __esm(() => {
+  init_devin_credentials();
+  init_devin_models();
+  init_devin_request();
+  init_subscription_antigravity_session();
+  init_subscription_models_command();
+});
+
 // src/subscription-models-command.ts
 var exports_subscription_models_command = {};
 __export(exports_subscription_models_command, {
@@ -110413,11 +110535,15 @@ __export(exports_subscription_models_command, {
   SECRET_GUARD_MESSAGE: () => SECRET_GUARD_MESSAGE,
   SUBSCRIPTION_MODELS_USAGE: () => SUBSCRIPTION_MODELS_USAGE,
   SUBSCRIPTION_MODEL_LIST_SCHEMA: () => SUBSCRIPTION_MODEL_LIST_SCHEMA,
+  buildModelListEnvelope: () => buildModelListEnvelope,
   defaultSubscriptionModelsDeps: () => defaultSubscriptionModelsDeps,
   exitCodeFor: () => exitCodeFor,
+  modelListFail: () => modelListFail,
+  modelListFailureOf: () => modelListFailureOf,
   parseSubscriptionModelsArgs: () => parseSubscriptionModelsArgs,
   reportSubscriptionInternalError: () => reportSubscriptionInternalError,
   runAntigravityRawModelList: () => runAntigravityRawModelList,
+  runModelListWith: () => runModelListWith,
   subscriptionModelsCommand: () => subscriptionModelsCommand
 });
 function exitCodeFor(failure) {
@@ -110444,11 +110570,11 @@ function defaultSubscriptionModelsDeps() {
 function parseSubscriptionModelsArgs(argv) {
   const positionals = argv.filter((a) => !a.startsWith("-"));
   const flags = argv.filter((a) => a.startsWith("-"));
-  const positionalsOk = positionals.length === 2 && positionals[0] === "models" && positionals[1] === "antigravity";
+  const positionalsOk = positionals.length === 2 && positionals[0] === "models" && MODEL_LIST_PROVIDERS.includes(positionals[1]);
   const flagsOk = flags.length === 2 && flags.includes("--raw") && flags.includes("--json");
-  return positionalsOk && flagsOk ? { ok: true, provider: "antigravity" } : { ok: false };
+  return positionalsOk && flagsOk ? { ok: true, provider: positionals[1] } : { ok: false };
 }
-function buildEnvelope(facts, failure, body) {
+function buildModelListEnvelope(facts, failure, body) {
   return {
     schema: SUBSCRIPTION_MODEL_LIST_SCHEMA,
     ...facts.provider !== undefined ? { provider: facts.provider } : {},
@@ -110459,25 +110585,27 @@ function buildEnvelope(facts, failure, body) {
     ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
     tokenRefreshed: facts.tokenRefreshed,
     ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
+    ...facts.teamSettingsUrl !== undefined ? { teamSettingsUrl: facts.teamSettingsUrl } : {},
+    ...facts.teamSettingsHttpStatus !== undefined ? { teamSettingsHttpStatus: facts.teamSettingsHttpStatus } : {},
     ...failure ? { failure } : {},
     ...body !== undefined ? { body } : {}
   };
 }
-function failureOf3(cls, code, httpStatus) {
+function modelListFailureOf(cls, code, httpStatus) {
   return failureOf2(cls, code, httpStatus);
 }
 function listFailure(value, status) {
   const models = value !== null && typeof value === "object" && !Array.isArray(value) ? value.models : undefined;
   if (models === null || typeof models !== "object" || Array.isArray(models)) {
-    return failureOf3("list_incomplete", "models_absent", status);
+    return modelListFailureOf("list_incomplete", "models_absent", status);
   }
   if (Object.keys(models).length === 0) {
-    return failureOf3("list_incomplete", "models_empty", status);
+    return modelListFailureOf("list_incomplete", "models_empty", status);
   }
   return null;
 }
-function fail(facts, failure) {
-  return { envelope: buildEnvelope(facts, failure), exitCode: exitCodeFor(failure) };
+function modelListFail(facts, failure) {
+  return { envelope: buildModelListEnvelope(facts, failure), exitCode: exitCodeFor(failure) };
 }
 function lineOf(envelope) {
   return `${JSON.stringify(envelope)}
@@ -110489,15 +110617,16 @@ function safeStderr(deps, line) {
   } catch {}
 }
 async function writeInternalFailure(deps, facts, code, stderrLine, secrets) {
-  const failure = failureOf3("internal", code);
+  const failure = modelListFailureOf("internal", code);
   safeStderr(deps, `${stderrLine}
 `);
-  const line = lineOf(buildEnvelope(facts, failure));
-  if (!secrets || !containsSecret(secrets, line)) {
-    try {
-      await deps.writeStdout(line);
-    } catch {}
+  let line = lineOf(buildModelListEnvelope(facts, failure));
+  if (secrets && containsSecret(secrets, line)) {
+    line = lineOf(buildModelListEnvelope({ tokenRefreshed: facts.tokenRefreshed }, failure));
   }
+  try {
+    await deps.writeStdout(line);
+  } catch {}
   return exitCodeFor(failure);
 }
 async function reportSubscriptionInternalError(deps) {
@@ -110516,34 +110645,35 @@ function classifyAvailableModels(facts, raw, timedOut) {
   facts.clientVersion = raw.clientVersion;
   facts.clientVersionSource = raw.clientVersionSource;
   const networkCode = timedOut ? "fetch_available_models_timeout" : "fetch_available_models_network_error";
-  if (raw.kind === "unreachable")
-    return fail(facts, failureOf3("network", networkCode));
+  if (raw.kind === "unreachable") {
+    return modelListFail(facts, modelListFailureOf("network", networkCode));
+  }
   facts.fetchedAt = raw.fetchedAt;
   facts.httpStatus = raw.status;
   if (raw.status < 200 || raw.status >= 300) {
-    return { envelope: buildEnvelope(facts), exitCode: EXIT.ok };
+    return { envelope: buildModelListEnvelope(facts), exitCode: EXIT.ok };
   }
   switch (raw.body.kind) {
     case "json": {
       const incomplete = listFailure(raw.body.value, raw.status);
       if (incomplete)
-        return fail(facts, incomplete);
+        return modelListFail(facts, incomplete);
       return {
-        envelope: buildEnvelope(facts, undefined, raw.body.text),
+        envelope: buildModelListEnvelope(facts, undefined, raw.body.text),
         exitCode: EXIT.ok,
         bodyText: raw.body.text
       };
     }
     case "not-json":
-      return fail(facts, failureOf3("list_incomplete", "body_not_json", raw.status));
+      return modelListFail(facts, modelListFailureOf("list_incomplete", "body_not_json", raw.status));
     default:
-      return fail(facts, failureOf3("network", networkCode, raw.status));
+      return modelListFail(facts, modelListFailureOf("network", networkCode, raw.status));
   }
 }
-async function determine(deps, secrets, facts) {
+async function determineAntigravity(deps, secrets, facts) {
   const session = await establishAntigravitySession(deps, secrets, facts);
   if (!session.ok)
-    return fail(facts, session.failure);
+    return modelListFail(facts, session.failure);
   const { accessToken, projectId } = session;
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), deps.httpTimeoutMs);
@@ -110557,14 +110687,12 @@ async function determine(deps, secrets, facts) {
     clearTimeout(timer);
   }
 }
-async function runAntigravityRawModelList(deps) {
-  const secrets = newSecrets();
-  const facts = { provider: "antigravity", tokenRefreshed: false };
+async function runModelListWith(deps, facts, secrets, determine) {
   let line;
   let exitCode;
   let bodyText;
   try {
-    const result = await determine(deps, secrets, facts);
+    const result = await determine();
     line = lineOf(result.envelope);
     exitCode = result.exitCode;
     bodyText = result.bodyText;
@@ -110583,27 +110711,53 @@ async function runAntigravityRawModelList(deps) {
   }
   return exitCode;
 }
+async function runAntigravityRawModelList(deps) {
+  const secrets = newSecrets();
+  const facts = { provider: "antigravity", tokenRefreshed: false };
+  return runModelListWith(deps, facts, secrets, () => determineAntigravity(deps, secrets, facts));
+}
 async function subscriptionModelsCommand(argv, deps = defaultSubscriptionModelsDeps()) {
-  if (!parseSubscriptionModelsArgs(argv).ok) {
+  const args = parseSubscriptionModelsArgs(argv);
+  if (!args.ok) {
     return writeInternalFailure(deps, { tokenRefreshed: false }, "usage", SUBSCRIPTION_MODELS_USAGE);
   }
+  if (args.provider === "devin") {
+    let devin;
+    try {
+      devin = await Promise.resolve().then(() => (init_subscription_devin_models(), exports_subscription_devin_models));
+    } catch {
+      return writeInternalFailure(deps, { provider: args.provider, tokenRefreshed: false }, "internal_error", INTERNAL_ERROR_MESSAGE);
+    }
+    return devin.runDevinRawModelList(deps);
+  }
   return runAntigravityRawModelList(deps);
 }
-var SUBSCRIPTION_MODEL_LIST_SCHEMA = "claudish.subscription-model-list.v1", FAILURE_CODES, EXIT, SUBSCRIPTION_MODELS_USAGE = "usage: claudish subscription models antigravity --raw --json", SECRET_GUARD_MESSAGE = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE = "[claudish subscription] internal error";
+var SUBSCRIPTION_MODEL_LIST_SCHEMA = "claudish.subscription-model-list.v1", FAILURE_CODES, EXIT, SUBSCRIPTION_MODELS_USAGE = "usage: claudish subscription models antigravity|devin --raw --json", SECRET_GUARD_MESSAGE = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE = "[claudish subscription] internal error", MODEL_LIST_PROVIDERS;
 var init_subscription_models_command = __esm(() => {
   init_antigravity_token();
   init_antigravity_user();
   init_subscription_antigravity_session();
   FAILURE_CODES = {
-    credential_missing: SESSION_FAILURE_CODES.credential_missing,
+    credential_missing: [...SESSION_FAILURE_CODES.credential_missing, "devin_credential_absent"],
     keychain_locked: SESSION_FAILURE_CODES.keychain_locked,
     mint_failed: SESSION_FAILURE_CODES.mint_failed,
     network: [
       ...SESSION_FAILURE_CODES.network,
       "fetch_available_models_network_error",
-      "fetch_available_models_timeout"
+      "fetch_available_models_timeout",
+      "model_configs_network_error",
+      "model_configs_timeout",
+      "team_settings_network_error",
+      "team_settings_timeout"
+    ],
+    list_incomplete: [
+      "models_absent",
+      "models_empty",
+      "body_not_json",
+      "configs_empty",
+      "team_settings_http_error",
+      "allowed_uids_empty"
     ],
-    list_incomplete: ["models_absent", "models_empty", "body_not_json"],
     internal: ["usage", "secret_guard", "internal_error"]
   };
   EXIT = {
@@ -110616,6 +110770,7 @@ var init_subscription_models_command = __esm(() => {
     network: 6,
     list_incomplete: 7
   };
+  MODEL_LIST_PROVIDERS = ["antigravity", "devin"];
 });
 
 // src/subscription-dispatch.ts
@@ -110643,6 +110798,232 @@ function probeLoadFailureLine() {
 var SUBSCRIPTION_PROBE_SCHEMA = "claudish.subscription-probe.v1";
 var init_subscription_dispatch = () => {};
 
+// src/subscription-secret-guard.ts
+import { readFile as readFile8, stat as stat2 } from "fs/promises";
+function redactSecretValues(text, secrets) {
+  let out = text;
+  const values = [...secrets.values].sort((a, b) => b.length - a.length);
+  for (const value of values) {
+    for (const form of new Set([value, value.replaceAll("/", "\\/")])) {
+      if (out.includes(form))
+        out = out.replaceAll(form, REDACTED2);
+    }
+  }
+  return { text: out, redacted: out !== text };
+}
+function jsonUnescapedForms(text) {
+  const forms = [];
+  if (text === undefined)
+    return { forms, complete: true };
+  let current = text;
+  for (let round = 0;round < MAX_UNESCAPE_ROUNDS; round++) {
+    const next = current.replace(JSON_ESCAPE, (_match, hex, letter) => hex !== undefined ? String.fromCharCode(Number.parseInt(hex, 16)) : SIMPLE_ESCAPES[letter]);
+    if (next === current)
+      return { forms, complete: true };
+    forms.push(next);
+    current = next;
+  }
+  return { forms, complete: false };
+}
+async function readCapped(res, cap) {
+  if (!res.body)
+    return "";
+  const reader = res.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    size += value.byteLength;
+    if (size > cap) {
+      await reader.cancel().catch(() => {});
+      return null;
+    }
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function defaultReadRequestFile(path) {
+  const info = await stat2(path);
+  if (!info.isFile())
+    throw new Error("not a file");
+  if (info.size > PROBE_REQUEST_FILE_CAP_BYTES)
+    return null;
+  return readFile8(path, "utf8");
+}
+async function readRequestFileChecked(read, path) {
+  let text;
+  try {
+    text = await read(path);
+  } catch {
+    return { ok: false, code: "request_file_unreadable" };
+  }
+  if (text === null)
+    return { ok: false, code: "request_file_invalid" };
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return { ok: false, code: "request_file_invalid" };
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, code: "request_file_invalid" };
+  }
+  return { ok: true, text, value };
+}
+var PROBE_BODY_CAP_BYTES, PROBE_REQUEST_FILE_CAP_BYTES, REDACTED2 = "[REDACTED]", JSON_ESCAPE, SIMPLE_ESCAPES, MAX_UNESCAPE_ROUNDS = 64;
+var init_subscription_secret_guard = __esm(() => {
+  PROBE_BODY_CAP_BYTES = 512 * 1024;
+  PROBE_REQUEST_FILE_CAP_BYTES = 8 * 1024 * 1024;
+  JSON_ESCAPE = /\\(?:u([0-9a-fA-F]{4})|(["\\/bfnrt]))/g;
+  SIMPLE_ESCAPES = {
+    '"': '"',
+    "\\": "\\",
+    "/": "/",
+    b: "\b",
+    f: "\f",
+    n: `
+`,
+    r: "\r",
+    t: "\t"
+  };
+});
+
+// src/subscription-devin-probe.ts
+var exports_subscription_devin_probe = {};
+__export(exports_subscription_devin_probe, {
+  DEVIN_PROBE_REQUEST_FILE_MESSAGE: () => DEVIN_PROBE_REQUEST_FILE_MESSAGE,
+  buildDevinProbePayload: () => buildDevinProbePayload,
+  runDevinProbe: () => runDevinProbe
+});
+function buildDevinProbePayload(model, claudeRequest) {
+  const adapter = new DevinAPIFormat(model);
+  adapter.setResponseWireFormat("connect-proto");
+  adapter.reset();
+  const messages = adapter.convertMessages(claudeRequest, filterIdentity);
+  const tools = adapter.convertTools(claudeRequest);
+  const payload = adapter.buildPayload(claudeRequest, messages, tools);
+  adapter.prepareRequest(payload, claudeRequest);
+  payload.modelUid = model;
+  delete payload.effort;
+  return { payload, toolNameMap: adapter.getToolNameMap() };
+}
+async function decodeDevinAnswer(res, facts, model, toolNameMap) {
+  const head = await sniffDevinStreamHead(res);
+  if (head.kind !== "clean") {
+    facts.streamError = { code: head.code, retryable: head.kind === "retryable" };
+    return JSON.stringify({ error: { code: head.code, message: head.message } });
+  }
+  let apiError;
+  let measured;
+  let endOfStream = false;
+  const sse = createDevinConnectStream({}, head.response, {
+    modelName: model,
+    toolNameMap,
+    onTokenUpdate: (input, output) => {
+      measured = { input_tokens: input, output_tokens: output };
+    },
+    onServedModel: (uid) => {
+      facts.servedModel = uid;
+    },
+    onApiError: (code, message) => {
+      apiError ??= { code, message };
+    },
+    onEndOfStream: () => {
+      endOfStream = true;
+    }
+  });
+  const collected = await collectSseMessage(sse, model);
+  if (apiError) {
+    facts.streamError = {
+      code: apiError.code,
+      retryable: classifyDevinStreamError(apiError.code, apiError.message) === "retryable"
+    };
+  } else if (collected.streamError || !endOfStream) {
+    return null;
+  }
+  const { streamError: _internal, ...message } = collected;
+  if (measured)
+    message.usage = measured;
+  return JSON.stringify(message);
+}
+async function determineDevin2(deps, secrets, facts, args) {
+  const request = await readRequestFileChecked(deps.readRequestFile, args.requestFile);
+  if (!request.ok)
+    return probeFail(facts, probeFailureOf("internal", request.code));
+  const apiKey = readDevinSecrets(secrets);
+  if (!apiKey) {
+    return probeFail(facts, probeFailureOf("credential_missing", "devin_credential_absent"));
+  }
+  const { payload, toolNameMap } = buildDevinProbePayload(args.model, request.value);
+  const body = encodeDevinRequest(payload, { apiKey });
+  const url = `${readDevinServerUrl()}${CHAT_PATH}`;
+  facts.sourceUrl = stripUserinfo(url);
+  facts.clientVersion = DEVIN_CLI_VERSION;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), deps.requestTimeoutMs);
+  const networkFailure = () => probeFailureOf("network", controller.signal.aborted ? "get_chat_message_timeout" : "get_chat_message_network_error", facts.httpStatus);
+  try {
+    let res;
+    try {
+      res = await fetch(url, {
+        method: "POST",
+        headers: { ...devinAuthHeaders(apiKey), "content-type": CHAT_CONTENT_TYPE2 },
+        body,
+        signal: controller.signal,
+        redirect: "manual"
+      });
+    } catch {
+      return probeFail(facts, networkFailure());
+    }
+    facts.fetchedAt = new Date(deps.now()).toISOString();
+    facts.httpStatus = res.status;
+    if (!res.ok) {
+      let text;
+      try {
+        text = await readCapped(res, PROBE_BODY_CAP_BYTES);
+      } catch {
+        return probeFail(facts, networkFailure());
+      }
+      if (text === null) {
+        return probeFail(facts, probeFailureOf("list_incomplete", "body_too_large", res.status));
+      }
+      return probeBodyResult(facts, text, secrets, res.status);
+    }
+    const text = await decodeDevinAnswer(res, facts, args.model, toolNameMap);
+    if (text === null)
+      return probeFail(facts, networkFailure());
+    if (Buffer.byteLength(text, "utf8") > PROBE_BODY_CAP_BYTES) {
+      return probeFail(facts, probeFailureOf("list_incomplete", "body_too_large", res.status));
+    }
+    return probeBodyResult(facts, text, secrets, res.status);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function runDevinProbe(deps, args) {
+  const secrets = newSecrets();
+  const facts = { provider: "devin", model: args.model, tokenRefreshed: false };
+  return runProbeWith(deps, facts, secrets, DEVIN_PROBE_REQUEST_FILE_MESSAGE, () => determineDevin2(deps, secrets, facts, args));
+}
+var DEVIN_PROBE_REQUEST_FILE_MESSAGE = "[claudish subscription] the request file must hold one JSON object (an Anthropic Messages request)", CHAT_CONTENT_TYPE2 = "application/connect+proto";
+var init_subscription_devin_probe = __esm(() => {
+  init_devin_api_format();
+  init_devin_credential();
+  init_collect_sse_message();
+  init_devin_stream_head_sniffer();
+  init_openai_compat();
+  init_devin_connect();
+  init_devin_credentials();
+  init_devin_request();
+  init_devin2();
+  init_subscription_antigravity_session();
+  init_subscription_devin_models();
+  init_subscription_probe_command();
+  init_subscription_secret_guard();
+});
+
 // src/subscription-probe-command.ts
 var exports_subscription_probe_command = {};
 __export(exports_subscription_probe_command, {
@@ -110655,33 +111036,30 @@ __export(exports_subscription_probe_command, {
   REDACTED: () => REDACTED2,
   SUBSCRIPTION_PROBE_SCHEMA: () => SUBSCRIPTION_PROBE_SCHEMA,
   SUBSCRIPTION_PROBE_USAGE: () => SUBSCRIPTION_PROBE_USAGE,
+  buildProbeEnvelope: () => buildProbeEnvelope,
   buildProbeEnvelopeBody: () => buildProbeEnvelopeBody,
   defaultSubscriptionProbeDeps: () => defaultSubscriptionProbeDeps,
   isSubscriptionProbeArgv: () => isSubscriptionProbeArgv,
   jsonUnescapedForms: () => jsonUnescapedForms,
   parseSubscriptionProbeArgs: () => parseSubscriptionProbeArgs,
+  probeBodyResult: () => probeBodyResult,
   probeExitCodeFor: () => probeExitCodeFor,
+  probeFail: () => probeFail,
+  probeFailureOf: () => probeFailureOf,
+  readCapped: () => readCapped,
   redactSecretValues: () => redactSecretValues,
   reportProbeInternalError: () => reportProbeInternalError,
   runAntigravityProbe: () => runAntigravityProbe,
+  runProbeWith: () => runProbeWith,
   subscriptionProbeCommand: () => subscriptionProbeCommand
 });
 import { randomUUID as randomUUID12 } from "crypto";
-import { readFile as readFile8, stat as stat2 } from "fs/promises";
 function probeExitCodeFor(failure) {
   if (failure.class === "internal") {
     return CALLER_CODES.includes(failure.code) ? PROBE_EXIT.usage : PROBE_EXIT.internal;
   }
   return PROBE_EXIT[failure.class];
 }
-async function defaultReadRequestFile(path) {
-  const info = await stat2(path);
-  if (!info.isFile())
-    throw new Error("not a file");
-  if (info.size > PROBE_REQUEST_FILE_CAP_BYTES)
-    return null;
-  return readFile8(path, "utf8");
-}
 function defaultSubscriptionProbeDeps() {
   return {
     platform: () => process.platform,
@@ -110725,15 +111103,20 @@ function parseSubscriptionProbeArgs(argv) {
   }
   const model = values.get("--model");
   const requestFile = values.get("--request-file");
-  if (positionals.length !== 2 || positionals[0] !== "probe" || positionals[1] !== "antigravity" || switches.size !== 2 || model === undefined || requestFile === undefined) {
+  if (positionals.length !== 2 || positionals[0] !== "probe" || !PROBE_PROVIDERS.includes(positionals[1]) || switches.size !== 2 || model === undefined || requestFile === undefined) {
     return { ok: false };
   }
-  return { ok: true, provider: "antigravity", model, requestFile };
+  return {
+    ok: true,
+    provider: positionals[1],
+    model,
+    requestFile
+  };
 }
-function failureOf4(cls, code, httpStatus) {
+function probeFailureOf(cls, code, httpStatus) {
   return failureOf2(cls, code, httpStatus);
 }
-function buildEnvelope2(facts, failure, body) {
+function buildProbeEnvelope(facts, failure, body) {
   return {
     schema: SUBSCRIPTION_PROBE_SCHEMA,
     ...facts.provider !== undefined ? { provider: facts.provider } : {},
@@ -110745,12 +111128,27 @@ function buildEnvelope2(facts, failure, body) {
     ...facts.clientVersionSource !== undefined ? { clientVersionSource: facts.clientVersionSource } : {},
     tokenRefreshed: facts.tokenRefreshed,
     ...facts.httpStatus !== undefined ? { httpStatus: facts.httpStatus } : {},
+    ...facts.servedModel !== undefined ? { servedModel: facts.servedModel } : {},
+    ...facts.streamError !== undefined ? { streamError: facts.streamError } : {},
     ...failure ? { failure } : {},
     ...body ? { bodyRedacted: body.redacted, body: body.text } : {}
   };
 }
-function fail2(facts, failure) {
-  return { envelope: buildEnvelope2(facts, failure), exitCode: probeExitCodeFor(failure) };
+function probeFail(facts, failure) {
+  return { envelope: buildProbeEnvelope(facts, failure), exitCode: probeExitCodeFor(failure) };
+}
+function probeBodyResult(facts, text, secrets, status) {
+  const body = redactSecretValues(text, secrets);
+  const unescaped = jsonUnescapedForms(body.text);
+  if (!unescaped.complete) {
+    return probeFail(facts, probeFailureOf("list_incomplete", "body_unverifiable", status));
+  }
+  return {
+    envelope: buildProbeEnvelope(facts, undefined, body),
+    exitCode: PROBE_EXIT.ok,
+    bodyText: body.text,
+    bodyForms: unescaped.forms
+  };
 }
 function lineOf2(envelope) {
   return `${JSON.stringify(envelope)}
@@ -110762,62 +111160,41 @@ function safeStderr2(deps, line) {
   } catch {}
 }
 async function writeInternalFailure2(deps, facts, code, stderrLine, secrets) {
-  const failure = failureOf4("internal", code);
+  const failure = probeFailureOf("internal", code);
   safeStderr2(deps, `${stderrLine}
 `);
-  let line = lineOf2(buildEnvelope2(facts, failure));
+  let line = lineOf2(buildProbeEnvelope(facts, failure));
   if (secrets && containsSecret(secrets, line)) {
-    line = lineOf2(buildEnvelope2({ tokenRefreshed: facts.tokenRefreshed }, failure));
+    line = lineOf2(buildProbeEnvelope({ tokenRefreshed: facts.tokenRefreshed }, failure));
   }
   try {
     await deps.writeStdout(line);
   } catch {}
   return probeExitCodeFor(failure);
 }
-function redactSecretValues(text, secrets) {
-  let out = text;
-  const values = [...secrets.values].sort((a, b) => b.length - a.length);
-  for (const value of values) {
-    for (const form of new Set([value, value.replaceAll("/", "\\/")])) {
-      if (out.includes(form))
-        out = out.replaceAll(form, REDACTED2);
-    }
-  }
-  return { text: out, redacted: out !== text };
-}
-function jsonUnescapedForms(text) {
-  const forms = [];
-  if (text === undefined)
-    return { forms, complete: true };
-  let current = text;
-  for (let round = 0;round < MAX_UNESCAPE_ROUNDS; round++) {
-    const next = current.replace(JSON_ESCAPE, (_match, hex, letter) => hex !== undefined ? String.fromCharCode(Number.parseInt(hex, 16)) : SIMPLE_ESCAPES[letter]);
-    if (next === current)
-      return { forms, complete: true };
-    forms.push(next);
-    current = next;
-  }
-  return { forms, complete: false };
-}
-async function readRequest(deps, path) {
-  let text;
+async function runProbeWith(deps, facts, secrets, requestFileMessage, determine) {
+  let result;
   try {
-    text = await deps.readRequestFile(path);
+    result = await determine();
   } catch {
-    return { ok: false, code: "request_file_unreadable" };
+    return writeInternalFailure2(deps, { provider: facts.provider, model: facts.model, tokenRefreshed: facts.tokenRefreshed }, "internal_error", INTERNAL_ERROR_MESSAGE2, secrets);
+  }
+  if (result.envelope.failure?.code === "request_file_unreadable" || result.envelope.failure?.code === "request_file_invalid") {
+    safeStderr2(deps, `${requestFileMessage}
+`);
+  }
+  const line = lineOf2(result.envelope);
+  if (containsSecret(secrets, line, result.bodyText, ...result.bodyForms ?? [])) {
+    return writeInternalFailure2(deps, facts, "secret_guard", SECRET_GUARD_MESSAGE2, secrets);
   }
-  if (text === null)
-    return { ok: false, code: "request_file_invalid" };
-  let value;
   try {
-    value = JSON.parse(text);
+    await deps.writeStdout(line);
   } catch {
-    return { ok: false, code: "request_file_invalid" };
-  }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return { ok: false, code: "request_file_invalid" };
+    safeStderr2(deps, `${INTERNAL_ERROR_MESSAGE2}
+`);
+    return PROBE_EXIT.internal;
   }
-  return { ok: true, text };
+  return result.exitCode;
 }
 function buildProbeEnvelopeBody(model, projectId, tierId, requestText, userPromptId = randomUUID12()) {
   const head = JSON.stringify({ model, project: projectId, user_prompt_id: userPromptId });
@@ -110827,32 +111204,13 @@ function buildProbeEnvelopeBody(model, projectId, tierId, requestText, userPromp
 function createActivityRequestId3() {
   return Math.random().toString(36).substring(7);
 }
-async function readCapped(res, cap) {
-  if (!res.body)
-    return "";
-  const reader = res.body.getReader();
-  const chunks = [];
-  let size = 0;
-  for (;; ) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    size += value.byteLength;
-    if (size > cap) {
-      await reader.cancel().catch(() => {});
-      return null;
-    }
-    chunks.push(value);
-  }
-  return Buffer.concat(chunks).toString("utf8");
-}
-async function determine2(deps, secrets, facts, args) {
-  const request = await readRequest(deps, args.requestFile);
+async function determineAntigravity2(deps, secrets, facts, args) {
+  const request = await readRequestFileChecked(deps.readRequestFile, args.requestFile);
   if (!request.ok)
-    return fail2(facts, failureOf4("internal", request.code));
+    return probeFail(facts, probeFailureOf("internal", request.code));
   const session = await establishAntigravitySession(deps, secrets, facts);
   if (!session.ok)
-    return fail2(facts, session.failure);
+    return probeFail(facts, session.failure);
   const url = `${antigravityHost()}/v1internal:generateContent`;
   const version = resolveAntigravityClientVersion();
   facts.sourceUrl = stripUserinfo(url);
@@ -110860,7 +111218,7 @@ async function determine2(deps, secrets, facts, args) {
   facts.clientVersionSource = version.source;
   const controller = new AbortController;
   const timer = setTimeout(() => controller.abort(), deps.requestTimeoutMs);
-  const networkFailure = () => failureOf4("network", controller.signal.aborted ? "generate_content_timeout" : "generate_content_network_error", facts.httpStatus);
+  const networkFailure = () => probeFailureOf("network", controller.signal.aborted ? "generate_content_timeout" : "generate_content_network_error", facts.httpStatus);
   try {
     let res;
     try {
@@ -110877,7 +111235,7 @@ async function determine2(deps, secrets, facts, args) {
         redirect: "manual"
       });
     } catch {
-      return fail2(facts, networkFailure());
+      return probeFail(facts, networkFailure());
     }
     facts.fetchedAt = new Date(deps.now()).toISOString();
     facts.httpStatus = res.status;
@@ -110885,28 +111243,18 @@ async function determine2(deps, secrets, facts, args) {
     try {
       text = await readCapped(res, PROBE_BODY_CAP_BYTES);
     } catch {
-      return fail2(facts, networkFailure());
+      return probeFail(facts, networkFailure());
     }
     if (text === null)
-      return fail2(facts, failureOf4("list_incomplete", "body_too_large", res.status));
+      return probeFail(facts, probeFailureOf("list_incomplete", "body_too_large", res.status));
     if (res.ok) {
       try {
         JSON.parse(text);
       } catch {
-        return fail2(facts, failureOf4("list_incomplete", "body_not_json", res.status));
+        return probeFail(facts, probeFailureOf("list_incomplete", "body_not_json", res.status));
       }
     }
-    const body = redactSecretValues(text, secrets);
-    const unescaped = jsonUnescapedForms(body.text);
-    if (!unescaped.complete) {
-      return fail2(facts, failureOf4("list_incomplete", "body_unverifiable", res.status));
-    }
-    return {
-      envelope: buildEnvelope2(facts, undefined, body),
-      exitCode: PROBE_EXIT.ok,
-      bodyText: body.text,
-      bodyForms: unescaped.forms
-    };
+    return probeBodyResult(facts, text, secrets, res.status);
   } finally {
     clearTimeout(timer);
   }
@@ -110914,28 +111262,7 @@ async function determine2(deps, secrets, facts, args) {
 async function runAntigravityProbe(deps, args) {
   const secrets = newSecrets();
   const facts = { provider: "antigravity", model: args.model, tokenRefreshed: false };
-  let result;
-  try {
-    result = await determine2(deps, secrets, facts, args);
-  } catch {
-    return writeInternalFailure2(deps, { provider: facts.provider, model: facts.model, tokenRefreshed: facts.tokenRefreshed }, "internal_error", INTERNAL_ERROR_MESSAGE2, secrets);
-  }
-  if (result.envelope.failure?.code === "request_file_unreadable" || result.envelope.failure?.code === "request_file_invalid") {
-    safeStderr2(deps, `${PROBE_REQUEST_FILE_MESSAGE}
-`);
-  }
-  const line = lineOf2(result.envelope);
-  if (containsSecret(secrets, line, result.bodyText, ...result.bodyForms ?? [])) {
-    return writeInternalFailure2(deps, facts, "secret_guard", SECRET_GUARD_MESSAGE2, secrets);
-  }
-  try {
-    await deps.writeStdout(line);
-  } catch {
-    safeStderr2(deps, `${INTERNAL_ERROR_MESSAGE2}
-`);
-    return PROBE_EXIT.internal;
-  }
-  return result.exitCode;
+  return runProbeWith(deps, facts, secrets, PROBE_REQUEST_FILE_MESSAGE, () => determineAntigravity2(deps, secrets, facts, args));
 }
 async function reportProbeInternalError(deps) {
   let resolved;
@@ -110953,23 +111280,36 @@ async function subscriptionProbeCommand(argv, deps = defaultSubscriptionProbeDep
   if (!args.ok) {
     return writeInternalFailure2(deps, { tokenRefreshed: false }, "usage", SUBSCRIPTION_PROBE_USAGE);
   }
+  if (args.provider === "devin") {
+    let devin;
+    try {
+      devin = await Promise.resolve().then(() => (init_subscription_devin_probe(), exports_subscription_devin_probe));
+    } catch {
+      return writeInternalFailure2(deps, { provider: args.provider, model: args.model, tokenRefreshed: false }, "internal_error", INTERNAL_ERROR_MESSAGE2);
+    }
+    return devin.runDevinProbe(deps, args);
+  }
   return runAntigravityProbe(deps, args);
 }
-var PROBE_FAILURE_CODES, PROBE_EXIT, CALLER_CODES, PROBE_BODY_CAP_BYTES, PROBE_REQUEST_FILE_CAP_BYTES, REDACTED2 = "[REDACTED]", SUBSCRIPTION_PROBE_USAGE = "usage: claudish subscription probe antigravity --model <wire-model-id> --request-file <path> --raw --json", PROBE_REQUEST_FILE_MESSAGE = "[claudish subscription] the request file must hold one JSON object (the inner Gemini request)", SECRET_GUARD_MESSAGE2 = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE2 = "[claudish subscription] internal error", JSON_ESCAPE, SIMPLE_ESCAPES, MAX_UNESCAPE_ROUNDS = 64;
+var PROBE_FAILURE_CODES, PROBE_EXIT, CALLER_CODES, SUBSCRIPTION_PROBE_USAGE = "usage: claudish subscription probe antigravity|devin --model <wire-model-id> --request-file <path> --raw --json", PROBE_REQUEST_FILE_MESSAGE = "[claudish subscription] the request file must hold one JSON object (the inner Gemini request)", SECRET_GUARD_MESSAGE2 = "[claudish subscription] refused: output contained a credential value", INTERNAL_ERROR_MESSAGE2 = "[claudish subscription] internal error", PROBE_PROVIDERS;
 var init_subscription_probe_command = __esm(() => {
   init_antigravity_token();
   init_antigravity_user();
   init_subscription_antigravity_session();
   init_subscription_dispatch();
+  init_subscription_secret_guard();
   init_subscription_dispatch();
+  init_subscription_secret_guard();
   PROBE_FAILURE_CODES = {
-    credential_missing: SESSION_FAILURE_CODES.credential_missing,
+    credential_missing: [...SESSION_FAILURE_CODES.credential_missing, "devin_credential_absent"],
     keychain_locked: SESSION_FAILURE_CODES.keychain_locked,
     mint_failed: SESSION_FAILURE_CODES.mint_failed,
     network: [
       ...SESSION_FAILURE_CODES.network,
       "generate_content_network_error",
-      "generate_content_timeout"
+      "generate_content_timeout",
+      "get_chat_message_network_error",
+      "get_chat_message_timeout"
     ],
     list_incomplete: ["body_too_large", "body_not_json", "body_unverifiable"],
     internal: [
@@ -110995,20 +111335,7 @@ var init_subscription_probe_command = __esm(() => {
     "request_file_unreadable",
     "request_file_invalid"
   ];
-  PROBE_BODY_CAP_BYTES = 512 * 1024;
-  PROBE_REQUEST_FILE_CAP_BYTES = 8 * 1024 * 1024;
-  JSON_ESCAPE = /\\(?:u([0-9a-fA-F]{4})|(["\\/bfnrt]))/g;
-  SIMPLE_ESCAPES = {
-    '"': '"',
-    "\\": "\\",
-    "/": "/",
-    b: "\b",
-    f: "\f",
-    n: `
-`,
-    r: "\r",
-    t: "\t"
-  };
+  PROBE_PROVIDERS = ["antigravity", "devin"];
 });
 
 // src/account-forecast-render.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudish",
-  "version": "14.15.1",
+  "version": "14.16.0",
   "description": "Run Claude Code with any model - OpenRouter, Ollama, LM Studio & local models",
   "type": "module",
   "main": "./dist/index.js",
@@ -71,10 +71,10 @@
     "ai"
   ],
   "optionalDependencies": {
-    "@claudish/magmux-darwin-arm64": "14.15.1",
-    "@claudish/magmux-darwin-x64": "14.15.1",
-    "@claudish/magmux-linux-arm64": "14.15.1",
-    "@claudish/magmux-linux-x64": "14.15.1"
+    "@claudish/magmux-darwin-arm64": "14.16.0",
+    "@claudish/magmux-darwin-x64": "14.16.0",
+    "@claudish/magmux-linux-arm64": "14.16.0",
+    "@claudish/magmux-linux-x64": "14.16.0"
   },
   "author": "Jack Rudenko <i@madappgang.com>",
   "license": "MIT",