@costrict/csc 4.0.1

package/dist/chunk-p5rg8b87.js

@@ -0,0 +1,157 @@
+// @bun
+import {
+  init_pluginOperations,
+  updatePluginOp
+} from "./chunk-k04vbmv4.js";
+import {
+  getDeclaredMarketplaces,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  isInstallationRelevantToCurrentProject,
+  loadInstalledPluginsFromDisk,
+  loadKnownMarketplacesConfig,
+  parsePluginIdentifier,
+  refreshMarketplace
+} from "./chunk-97kwfkef.js";
+import {
+  init_config1 as init_config,
+  init_schemas,
+  isMarketplaceAutoUpdate,
+  shouldSkipPluginAutoupdate
+} from "./chunk-qp1047f9.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-z6e5jp2w.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/pluginAutoupdate.ts
+function onPluginsAutoUpdated(callback) {
+  pluginUpdateCallback = callback;
+  if (pendingNotification !== null && pendingNotification.length > 0) {
+    callback(pendingNotification);
+    pendingNotification = null;
+  }
+  return () => {
+    pluginUpdateCallback = null;
+  };
+}
+async function getAutoUpdateEnabledMarketplaces() {
+  const config = await loadKnownMarketplacesConfig();
+  const declared = getDeclaredMarketplaces();
+  const enabled = new Set;
+  for (const [name, entry] of Object.entries(config)) {
+    const declaredAutoUpdate = declared[name]?.autoUpdate;
+    const autoUpdate = declaredAutoUpdate !== undefined ? declaredAutoUpdate : isMarketplaceAutoUpdate(name, entry);
+    if (autoUpdate) {
+      enabled.add(name.toLowerCase());
+    }
+  }
+  return enabled;
+}
+async function updatePlugin(pluginId, installations) {
+  let wasUpdated = false;
+  for (const { scope } of installations) {
+    try {
+      const result = await updatePluginOp(pluginId, scope);
+      if (result.success && !result.alreadyUpToDate) {
+        wasUpdated = true;
+        logForDebugging(`Plugin autoupdate: updated ${pluginId} from ${result.oldVersion} to ${result.newVersion}`);
+      } else if (!result.alreadyUpToDate) {
+        logForDebugging(`Plugin autoupdate: failed to update ${pluginId}: ${result.message}`, { level: "warn" });
+      }
+    } catch (error) {
+      logForDebugging(`Plugin autoupdate: error updating ${pluginId}: ${errorMessage(error)}`, { level: "warn" });
+    }
+  }
+  return wasUpdated ? pluginId : null;
+}
+async function updatePluginsForMarketplaces(marketplaceNames) {
+  const installedPlugins = loadInstalledPluginsFromDisk();
+  const pluginIds = Object.keys(installedPlugins.plugins);
+  if (pluginIds.length === 0) {
+    return [];
+  }
+  const results = await Promise.allSettled(pluginIds.map(async (pluginId) => {
+    const { marketplace } = parsePluginIdentifier(pluginId);
+    if (!marketplace || !marketplaceNames.has(marketplace.toLowerCase())) {
+      return null;
+    }
+    const allInstallations = installedPlugins.plugins[pluginId];
+    if (!allInstallations || allInstallations.length === 0) {
+      return null;
+    }
+    const relevantInstallations = allInstallations.filter(isInstallationRelevantToCurrentProject);
+    if (relevantInstallations.length === 0) {
+      return null;
+    }
+    return updatePlugin(pluginId, relevantInstallations);
+  }));
+  return results.filter((r) => r.status === "fulfilled" && r.value !== null).map((r) => r.value);
+}
+async function updatePlugins(autoUpdateEnabledMarketplaces) {
+  return updatePluginsForMarketplaces(autoUpdateEnabledMarketplaces);
+}
+function autoUpdateMarketplacesAndPluginsInBackground() {
+  (async () => {
+    if (shouldSkipPluginAutoupdate()) {
+      logForDebugging("Plugin autoupdate: skipped (auto-updater disabled)");
+      return;
+    }
+    try {
+      const autoUpdateEnabledMarketplaces = await getAutoUpdateEnabledMarketplaces();
+      if (autoUpdateEnabledMarketplaces.size === 0) {
+        return;
+      }
+      const refreshResults = await Promise.allSettled(Array.from(autoUpdateEnabledMarketplaces).map(async (name) => {
+        try {
+          await refreshMarketplace(name, undefined, {
+            disableCredentialHelper: true
+          });
+        } catch (error) {
+          logForDebugging(`Plugin autoupdate: failed to refresh marketplace ${name}: ${errorMessage(error)}`, { level: "warn" });
+        }
+      }));
+      const failures = refreshResults.filter((r) => r.status === "rejected");
+      if (failures.length > 0) {
+        logForDebugging(`Plugin autoupdate: ${failures.length} marketplace refresh(es) failed`, { level: "warn" });
+      }
+      logForDebugging("Plugin autoupdate: checking installed plugins");
+      const updatedPlugins = await updatePlugins(autoUpdateEnabledMarketplaces);
+      if (updatedPlugins.length > 0) {
+        if (pluginUpdateCallback) {
+          pluginUpdateCallback(updatedPlugins);
+        } else {
+          pendingNotification = updatedPlugins;
+        }
+      }
+    } catch (error) {
+      logError(error);
+    }
+  })();
+}
+var pluginUpdateCallback = null, pendingNotification = null;
+var init_pluginAutoupdate = __esm(() => {
+  init_pluginOperations();
+  init_config();
+  init_debug();
+  init_errors();
+  init_log();
+  init_installedPluginsManager();
+  init_marketplaceManager();
+  init_pluginIdentifier();
+  init_schemas();
+});
+
+export { onPluginsAutoUpdated, updatePluginsForMarketplaces, autoUpdateMarketplacesAndPluginsInBackground, init_pluginAutoupdate };

package/dist/chunk-p7vkh4wx.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/tools/TungstenTool/TungstenTool.js
+var TungstenTool, clearSessionsWithTungstenUsage = () => {}, resetInitializationState = () => {};
+var init_TungstenTool = __esm(() => {
+  TungstenTool = {
+    name: "TungstenTool",
+    isEnabled: () => false
+  };
+});
+
+export { TungstenTool, clearSessionsWithTungstenUsage, resetInitializationState, init_TungstenTool };

package/dist/chunk-p99pzx02.js

@@ -0,0 +1,65 @@
+// @bun
+import {
+  init_slowOperations,
+  jsonParse,
+  jsonStringify
+} from "./chunk-ctya0ggm.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-nh3cd07f.js";
+
+// src/bridge/workSecret.ts
+init_axios();
+init_slowOperations();
+function decodeWorkSecret(secret) {
+  const json = Buffer.from(secret, "base64url").toString("utf-8");
+  const parsed = jsonParse(json);
+  if (!parsed || typeof parsed !== "object" || !("version" in parsed) || parsed.version !== 1) {
+    throw new Error(`Unsupported work secret version: ${parsed && typeof parsed === "object" && "version" in parsed ? parsed.version : "unknown"}`);
+  }
+  const obj = parsed;
+  if (typeof obj.session_ingress_token !== "string" || obj.session_ingress_token.length === 0) {
+    throw new Error("Invalid work secret: missing or empty session_ingress_token");
+  }
+  if (typeof obj.api_base_url !== "string") {
+    throw new Error("Invalid work secret: missing api_base_url");
+  }
+  return parsed;
+}
+function buildSdkUrl(apiBaseUrl, sessionId) {
+  const isLocalhost = apiBaseUrl.includes("localhost") || apiBaseUrl.includes("127.0.0.1");
+  const protocol = apiBaseUrl.startsWith("https") ? "wss" : "ws";
+  const version = isLocalhost ? "v2" : "v1";
+  const host = apiBaseUrl.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return `${protocol}://${host}/${version}/session_ingress/ws/${sessionId}`;
+}
+function sameSessionId(a, b) {
+  if (a === b)
+    return true;
+  const aBody = a.slice(a.lastIndexOf("_") + 1);
+  const bBody = b.slice(b.lastIndexOf("_") + 1);
+  return aBody.length >= 4 && aBody === bBody;
+}
+function buildCCRv2SdkUrl(apiBaseUrl, sessionId) {
+  const base = apiBaseUrl.replace(/\/+$/, "");
+  return `${base}/v1/code/sessions/${sessionId}`;
+}
+async function registerWorker(sessionUrl, accessToken) {
+  const response = await axios_default.post(`${sessionUrl}/worker/register`, {}, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01"
+    },
+    timeout: 1e4
+  });
+  const raw = response.data?.worker_epoch;
+  const epoch = typeof raw === "string" ? Number(raw) : raw;
+  if (typeof epoch !== "number" || !Number.isFinite(epoch) || !Number.isSafeInteger(epoch)) {
+    throw new Error(`registerWorker: invalid worker_epoch in response: ${jsonStringify(response.data)}`);
+  }
+  return epoch;
+}
+
+export { decodeWorkSecret, buildSdkUrl, sameSessionId, buildCCRv2SdkUrl, registerWorker };

package/dist/chunk-p9ce1a80.js

@@ -0,0 +1,279 @@
+// @bun
+import {
+  StdioServerTransport,
+  init_stdio
+} from "./chunk-fbvwrs77.js";
+import {
+  createAbortController,
+  createAssistantMessage,
+  findToolByName,
+  getDefaultAppState,
+  getEmptyToolPermissionContext,
+  getErrorParts,
+  getTools,
+  hasPermissionsToUseTool,
+  init_AppStateStore,
+  init_Shell,
+  init_Tool,
+  init_abortController,
+  init_messages1 as init_messages,
+  init_permissions,
+  init_review,
+  init_toolErrors,
+  init_tools1 as init_tools,
+  init_zodToJsonSchema,
+  review_default,
+  setCwd,
+  zodToJsonSchema
+} 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"./chunk-bnrctxq5.js";
+import"./chunk-9663bsk0.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-gr2j2pnw.js";
+import"./chunk-m7gb3xym.js";
+import"./chunk-zgjh33vv.js";
+import {
+  createFileStateCacheWithSizeLimit,
+  init_fileStateCache
+} from "./chunk-j5bth84e.js";
+import"./chunk-39jcea92.js";
+import"./chunk-reta5k4w.js";
+import"./chunk-3z9478wf.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-eq5csq9z.js";
+import"./chunk-qezabsdm.js";
+import"./chunk-p7vkh4wx.js";
+import"./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 {
+  getMainLoopModel,
+  init_model
+} from "./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 {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  Server,
+  init_server,
+  init_types
+} from "./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"./chunk-fk80f449.js";
+import"./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 {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import {
+  init_slowOperations,
+  jsonStringify
+} from "./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import"./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"./chunk-qp2qdcda.js";
+
+// src/entrypoints/mcp.ts
+init_server();
+init_stdio();
+init_types();
+init_AppStateStore();
+init_review();
+init_Tool();
+init_tools();
+init_abortController();
+init_fileStateCache();
+init_log();
+init_messages();
+init_model();
+init_permissions();
+init_Shell();
+init_slowOperations();
+init_toolErrors();
+init_zodToJsonSchema();
+var MCP_COMMANDS = [review_default];
+async function startMCPServer(cwd, debug, verbose) {
+  const READ_FILE_STATE_CACHE_SIZE = 100;
+  const readFileStateCache = createFileStateCacheWithSizeLimit(READ_FILE_STATE_CACHE_SIZE);
+  setCwd(cwd);
+  const server = new Server({
+    name: "claude/tengu",
+    version: "4.0.1"
+  }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const toolPermissionContext = getEmptyToolPermissionContext();
+    const tools = getTools(toolPermissionContext);
+    return {
+      tools: await Promise.all(tools.map(async (tool) => {
+        let outputSchema;
+        if (tool.outputSchema) {
+          const convertedSchema = zodToJsonSchema(tool.outputSchema);
+          if (typeof convertedSchema === "object" && convertedSchema !== null && "type" in convertedSchema && convertedSchema.type === "object") {
+            outputSchema = convertedSchema;
+          }
+        }
+        return {
+          ...tool,
+          description: await tool.prompt({
+            getToolPermissionContext: async () => toolPermissionContext,
+            tools,
+            agents: []
+          }),
+          inputSchema: zodToJsonSchema(tool.inputSchema),
+          outputSchema
+        };
+      }))
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async ({ params: { name, arguments: args } }) => {
+    const toolPermissionContext = getEmptyToolPermissionContext();
+    const tools = getTools(toolPermissionContext);
+    const tool = findToolByName(tools, name);
+    if (!tool) {
+      throw new Error(`Tool ${name} not found`);
+    }
+    const toolUseContext = {
+      abortController: createAbortController(),
+      options: {
+        commands: MCP_COMMANDS,
+        tools,
+        mainLoopModel: getMainLoopModel(),
+        thinkingConfig: { type: "disabled" },
+        mcpClients: [],
+        mcpResources: {},
+        isNonInteractiveSession: true,
+        debug,
+        verbose,
+        agentDefinitions: { activeAgents: [], allAgents: [] }
+      },
+      getAppState: () => getDefaultAppState(),
+      setAppState: () => {},
+      messages: [],
+      readFileState: readFileStateCache,
+      setInProgressToolUseIDs: () => {},
+      setResponseLength: () => {},
+      updateFileHistoryState: () => {},
+      updateAttributionState: () => {}
+    };
+    try {
+      if (!tool.isEnabled()) {
+        throw new Error(`Tool ${name} is not enabled`);
+      }
+      const validationResult = await tool.validateInput?.(args ?? {}, toolUseContext);
+      if (validationResult && !validationResult.result) {
+        throw new Error(`Tool ${name} input is invalid: ${validationResult.message}`);
+      }
+      const finalResult = await tool.call(args ?? {}, toolUseContext, hasPermissionsToUseTool, createAssistantMessage({
+        content: []
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof finalResult === "string" ? finalResult : jsonStringify(finalResult.data)
+          }
+        ]
+      };
+    } catch (error) {
+      logError(error);
+      const parts = error instanceof Error ? getErrorParts(error) : [String(error)];
+      const errorText = parts.filter(Boolean).join(`
+`).trim() || "Error";
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: errorText
+          }
+        ]
+      };
+    }
+  });
+  async function runServer() {
+    const transport = new StdioServerTransport;
+    await server.connect(transport);
+  }
+  return await runServer();
+}
+export {
+  startMCPServer
+};