@costrict/csc 4.0.1

package/dist/chunk-tqvxvgcq.js

@@ -0,0 +1,390 @@
+// @bun
+import {
+  init_overlayContext,
+  useRegisterOverlay
+} from "./chunk-97kwfkef.js";
+import"./chunk-4nspekjp.js";
+import"./chunk-s2jznn2t.js";
+import"./chunk-zejm280k.js";
+import"./chunk-var1et7e.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-enz148g9.js";
+import"./chunk-jmt3t5ka.js";
+import"./chunk-3x2jaxpw.js";
+import"./chunk-wm26jyc3.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-bxcfz5gy.js";
+import"./chunk-3vxgde8h.js";
+import"./chunk-9k8qsaph.js";
+import {
+  getBridgeDisabledReason,
+  init_bridgeEnabled
+} from "./chunk-bnrctxq5.js";
+import {
+  BRIDGE_LOGIN_INSTRUCTION,
+  init_types
+} from "./chunk-9663bsk0.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-gr2j2pnw.js";
+import"./chunk-m7gb3xym.js";
+import"./chunk-zgjh33vv.js";
+import"./chunk-j5bth84e.js";
+import"./chunk-39jcea92.js";
+import"./chunk-reta5k4w.js";
+import {
+  init_useKeybinding
+} from "./chunk-3z9478wf.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-eq5csq9z.js";
+import"./chunk-qezabsdm.js";
+import"./chunk-p7vkh4wx.js";
+import {
+  getBridgeAccessToken,
+  init_bridgeConfig
+} from "./chunk-3sj7jkgr.js";
+import"./chunk-62xkxk9z.js";
+import"./chunk-ers3hn71.js";
+import"./chunk-5krq9sjq.js";
+import"./chunk-85em0j2s.js";
+import"./chunk-dmfnhfbm.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-ew2qn2ct.js";
+import"./chunk-3bes9fg8.js";
+import"./chunk-ygj29dpk.js";
+import"./chunk-6km733xr.js";
+import"./chunk-mx28h61f.js";
+import"./chunk-z915v06p.js";
+import"./chunk-rw0b3wq4.js";
+import"./chunk-ms3y5kf0.js";
+import"./chunk-pfc94kdv.js";
+import"./chunk-kwdta9bw.js";
+import"./chunk-3dy7fxmg.js";
+import"./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import"./chunk-1dz5e26z.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-xzc7k2hh.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import {
+  Dialog,
+  ListItem,
+  ThemedBox_default,
+  ThemedText,
+  init_src,
+  useKeybindings
+} from "./chunk-fk80f449.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-yjkamwzv.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-z6e5jp2w.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/design-system/Dialog.tsx
+var init_Dialog = __esm(() => {
+  init_src();
+});
+
+// src/components/design-system/ListItem.tsx
+var init_ListItem = __esm(() => {
+  init_src();
+});
+
+// src/commands/remoteControlServer/remoteControlServer.tsx
+import { spawn } from "child_process";
+import { resolve } from "path";
+function RemoteControlServer({ onDone }) {
+  const [status, setStatus] = import_react.useState(daemonStatus);
+  const [error, setError] = import_react.useState(null);
+  import_react.useEffect(() => {
+    if (daemonProcess && !daemonProcess.killed) {
+      setStatus("running");
+      return;
+    }
+    let cancelled = false;
+    (async () => {
+      const checkError = await checkPrerequisites();
+      if (cancelled)
+        return;
+      if (checkError) {
+        onDone(checkError, { display: "system" });
+        return;
+      }
+      setStatus("starting");
+      try {
+        startDaemon();
+        if (!cancelled) {
+          setStatus("running");
+          daemonStatus = "running";
+          onDone("Remote Control Server started. Use /remote-control-server to manage.", { display: "system" });
+        }
+      } catch (err) {
+        if (!cancelled) {
+          const msg = errorMessage(err);
+          setStatus("error");
+          setError(msg);
+          daemonStatus = "error";
+          onDone(`Remote Control Server failed to start: ${msg}`, {
+            display: "system"
+          });
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  if (status === "running" && daemonProcess && !daemonProcess.killed) {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ServerManagementDialog, {
+      onDone
+    }, undefined, false, undefined, this);
+  }
+  if (status === "error" && error) {
+    return null;
+  }
+  return null;
+}
+function ServerManagementDialog({ onDone }) {
+  useRegisterOverlay("remote-control-server-dialog");
+  const [focusIndex, setFocusIndex] = import_react.useState(2);
+  const logPreview = daemonLogs.slice(-5);
+  function handleStop() {
+    stopDaemon();
+    onDone("Remote Control Server stopped.", { display: "system" });
+  }
+  function handleRestart() {
+    stopDaemon();
+    try {
+      startDaemon();
+      onDone("Remote Control Server restarted.", { display: "system" });
+    } catch (err) {
+      onDone(`Failed to restart: ${errorMessage(err)}`, { display: "system" });
+    }
+  }
+  function handleContinue() {
+    onDone(undefined, { display: "skip" });
+  }
+  const ITEM_COUNT = 3;
+  useKeybindings({
+    "select:next": () => setFocusIndex((i) => (i + 1) % ITEM_COUNT),
+    "select:previous": () => setFocusIndex((i) => (i - 1 + ITEM_COUNT) % ITEM_COUNT),
+    "select:accept": () => {
+      if (focusIndex === 0) {
+        handleStop();
+      } else if (focusIndex === 1) {
+        handleRestart();
+      } else {
+        handleContinue();
+      }
+    }
+  }, { context: "Select" });
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Remote Control Server",
+    onCancel: handleContinue,
+    hideInputGuide: true,
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: [
+            "Remote Control Server is",
+            " ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              color: "success",
+              children: "running"
+            }, undefined, false, undefined, this),
+            daemonProcess ? ` (PID: ${daemonProcess.pid})` : ""
+          ]
+        }, undefined, true, undefined, this),
+        logPreview.length > 0 && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              dimColor: true,
+              children: "Recent logs:"
+            }, undefined, false, undefined, this),
+            logPreview.map((line, i) => /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              dimColor: true,
+              children: line
+            }, i, false, undefined, this))
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ListItem, {
+              isFocused: focusIndex === 0,
+              children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+                children: "Stop server"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ListItem, {
+              isFocused: focusIndex === 1,
+              children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+                children: "Restart server"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ListItem, {
+              isFocused: focusIndex === 2,
+              children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+                children: "Continue"
+              }, undefined, false, undefined, this)
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: "Enter to select \xB7 Esc to continue"
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+async function checkPrerequisites() {
+  const disabledReason = await getBridgeDisabledReason();
+  if (disabledReason) {
+    return disabledReason;
+  }
+  if (!getBridgeAccessToken()) {
+    return BRIDGE_LOGIN_INSTRUCTION;
+  }
+  return null;
+}
+function startDaemon() {
+  const dir = resolve(".");
+  const execArgs = [...process.execArgv, process.argv[1], "daemon", "start", `--dir=${dir}`];
+  const child = spawn(process.execPath, execArgs, {
+    cwd: dir,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false
+  });
+  daemonProcess = child;
+  daemonLogs = [];
+  child.stdout?.on("data", (data) => {
+    const lines = data.toString().trimEnd().split(`
+`);
+    for (const line of lines) {
+      daemonLogs.push(line);
+      if (daemonLogs.length > MAX_LOG_LINES) {
+        daemonLogs.shift();
+      }
+    }
+  });
+  child.stderr?.on("data", (data) => {
+    const lines = data.toString().trimEnd().split(`
+`);
+    for (const line of lines) {
+      daemonLogs.push(`[err] ${line}`);
+      if (daemonLogs.length > MAX_LOG_LINES) {
+        daemonLogs.shift();
+      }
+    }
+  });
+  child.on("exit", (code, signal) => {
+    daemonProcess = null;
+    daemonStatus = "stopped";
+    daemonLogs.push(`[daemon] exited (code=${code ?? "unknown"}, signal=${signal})`);
+  });
+  child.on("error", (err) => {
+    daemonProcess = null;
+    daemonStatus = "error";
+    daemonLogs.push(`[daemon] error: ${err.message}`);
+  });
+}
+function stopDaemon() {
+  if (daemonProcess && !daemonProcess.killed) {
+    daemonProcess.kill("SIGTERM");
+    const pid = daemonProcess.pid;
+    setTimeout(() => {
+      try {
+        if (pid)
+          process.kill(pid, 0);
+        if (daemonProcess && !daemonProcess.killed) {
+          daemonProcess.kill("SIGKILL");
+        }
+      } catch {}
+    }, 1e4);
+  }
+  daemonProcess = null;
+  daemonStatus = "stopped";
+}
+async function call(onDone, _context, _args) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(RemoteControlServer, {
+    onDone
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, daemonProcess = null, daemonStatus = "stopped", daemonLogs, MAX_LOG_LINES = 50;
+var init_remoteControlServer = __esm(() => {
+  init_bridgeEnabled();
+  init_bridgeConfig();
+  init_types();
+  init_Dialog();
+  init_ListItem();
+  init_overlayContext();
+  init_src();
+  init_useKeybinding();
+  init_errors();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  daemonLogs = [];
+});
+init_remoteControlServer();
+
+export {
+  call
+};

package/dist/chunk-ts2p6bv1.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  Anthropic,
+  AnthropicError,
+  BaseAnthropic,
+  Beta,
+  Messages,
+  init_client,
+  init_error,
+  init_resources
+} from "./chunk-7739pg2c.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/core/error.mjs
+var init_error2 = __esm(() => {
+  init_error();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/values.mjs
+var isArray = (val) => (isArray = Array.isArray, isArray(val)), isReadonlyArray;
+var init_values = __esm(() => {
+  init_error2();
+  isReadonlyArray = isArray;
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/headers.mjs
+function* iterateHeaders(headers) {
+  if (!headers)
+    return;
+  if (brand_privateNullableHeaders in headers) {
+    const { values, nulls } = headers;
+    yield* values.entries();
+    for (const name of nulls) {
+      yield [name, null];
+    }
+    return;
+  }
+  let shouldClear = false;
+  let iter;
+  if (headers instanceof Headers) {
+    iter = headers.entries();
+  } else if (isReadonlyArray(headers)) {
+    iter = headers;
+  } else {
+    shouldClear = true;
+    iter = Object.entries(headers ?? {});
+  }
+  for (let row of iter) {
+    const name = row[0];
+    if (typeof name !== "string")
+      throw new TypeError("expected header name to be a string");
+    const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
+    let didClear = false;
+    for (const value of values) {
+      if (value === undefined)
+        continue;
+      if (shouldClear && !didClear) {
+        didClear = true;
+        yield [name, null];
+      }
+      yield [name, value];
+    }
+  }
+}
+var brand_privateNullableHeaders, buildHeaders = (newHeaders) => {
+  const targetHeaders = new Headers;
+  const nullHeaders = new Set;
+  for (const headers of newHeaders) {
+    const seenHeaders = new Set;
+    for (const [name, value] of iterateHeaders(headers)) {
+      const lowerName = name.toLowerCase();
+      if (!seenHeaders.has(lowerName)) {
+        targetHeaders.delete(name);
+        seenHeaders.add(lowerName);
+      }
+      if (value === null) {
+        targetHeaders.delete(name);
+        nullHeaders.add(lowerName);
+      } else {
+        targetHeaders.append(name, value);
+        nullHeaders.delete(lowerName);
+      }
+    }
+  }
+  return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+var init_headers = __esm(() => {
+  init_values();
+  brand_privateNullableHeaders = Symbol.for("brand.privateNullableHeaders");
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/bytes.mjs
+var init_bytes = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/base64.mjs
+var init_base64 = __esm(() => {
+  init_error2();
+  init_bytes();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/env.mjs
+var readEnv = (env) => {
+  if (typeof globalThis.process !== "undefined") {
+    return globalThis.process.env?.[env]?.trim() ?? undefined;
+  }
+  if (typeof globalThis.Deno !== "undefined") {
+    return globalThis.Deno.env?.get?.(env)?.trim();
+  }
+  return;
+};
+var init_env = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/log.mjs
+var init_log = __esm(() => {
+  init_values();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/uuid.mjs
+var init_uuid = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils/sleep.mjs
+var init_sleep = () => {};
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/internal/utils.mjs
+var init_utils = __esm(() => {
+  init_values();
+  init_base64();
+  init_env();
+  init_log();
+  init_uuid();
+  init_sleep();
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/client.mjs
+function makeMessagesResource(client) {
+  const resource = new Messages(client);
+  delete resource.batches;
+  return resource;
+}
+function makeBetaResource(client) {
+  const resource = new Beta(client);
+  delete resource.messages.batches;
+  return resource;
+}
+var AnthropicFoundry;
+var init_client2 = __esm(() => {
+  init_headers();
+  init_error2();
+  init_utils();
+  init_client();
+  init_client();
+  init_resources();
+  AnthropicFoundry = class AnthropicFoundry extends Anthropic {
+    constructor({ baseURL = readEnv("ANTHROPIC_FOUNDRY_BASE_URL"), apiKey = readEnv("ANTHROPIC_FOUNDRY_API_KEY"), resource = readEnv("ANTHROPIC_FOUNDRY_RESOURCE"), azureADTokenProvider, dangerouslyAllowBrowser, ...opts } = {}) {
+      if (typeof azureADTokenProvider === "function") {
+        dangerouslyAllowBrowser = true;
+      }
+      if (!azureADTokenProvider && !apiKey) {
+        throw new AnthropicError("Missing credentials. Please pass one of `apiKey` and `azureTokenProvider`, or set the `ANTHROPIC_FOUNDRY_API_KEY` environment variable.");
+      }
+      if (azureADTokenProvider && apiKey) {
+        throw new AnthropicError("The `apiKey` and `azureADTokenProvider` arguments are mutually exclusive; only one can be passed at a time.");
+      }
+      if (!baseURL) {
+        if (!resource) {
+          throw new AnthropicError("Must provide one of the `baseURL` or `resource` arguments, or the `ANTHROPIC_FOUNDRY_RESOURCE` environment variable");
+        }
+        baseURL = `https://${resource}.services.ai.azure.com/anthropic/`;
+      } else {
+        if (resource) {
+          throw new AnthropicError("baseURL and resource are mutually exclusive");
+        }
+      }
+      super({
+        apiKey: azureADTokenProvider ?? apiKey,
+        baseURL,
+        ...opts,
+        ...dangerouslyAllowBrowser !== undefined ? { dangerouslyAllowBrowser } : {}
+      });
+      this.resource = null;
+      this.messages = makeMessagesResource(this);
+      this.beta = makeBetaResource(this);
+      this.models = undefined;
+    }
+    async authHeaders() {
+      if (typeof this._options.apiKey === "function") {
+        let token;
+        try {
+          token = await this._options.apiKey();
+        } catch (err) {
+          if (err instanceof AnthropicError)
+            throw err;
+          throw new AnthropicError(`Failed to get token from azureADTokenProvider: ${err.message}`, { cause: err });
+        }
+        if (typeof token !== "string" || !token) {
+          throw new AnthropicError(`Expected azureADTokenProvider function argument to return a string but it returned ${token}`);
+        }
+        return buildHeaders([{ Authorization: `Bearer ${token}` }]);
+      }
+      if (typeof this._options.apiKey === "string") {
+        return buildHeaders([{ "x-api-key": this.apiKey }]);
+      }
+      return;
+    }
+    validateHeaders() {
+      return;
+    }
+  };
+});
+
+// node_modules/.bun/@anthropic-ai+foundry-sdk@0.2.3+3c5d820c62823f0b/node_modules/@anthropic-ai/foundry-sdk/index.mjs
+var init_foundry_sdk = __esm(() => {
+  init_client2();
+  init_client2();
+});
+init_foundry_sdk();
+
+export {
+  AnthropicFoundry as default,
+  BaseAnthropic,
+  AnthropicFoundry
+};