@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-DRSC6ZRA.js

@@ -0,0 +1,36 @@
+import {
+  checkLicense,
+  init_license,
+  loadLicense
+} from "./chunk-IRQTM7DY.js";
+
+// src/lib/license-gate.ts
+init_license();
+var _cachedLicense = null;
+var _hasLicenseKey = false;
+async function initLicenseGate() {
+  const key = loadLicense();
+  _hasLicenseKey = key !== null && key.length > 0;
+  if (_hasLicenseKey) {
+    try {
+      _cachedLicense = await checkLicense();
+    } catch {
+      _cachedLicense = null;
+    }
+    return { license: _cachedLicense, hasKey: true };
+  }
+  return { license: null, hasKey: false };
+}
+function getCachedLicenseGate() {
+  return {
+    license: _cachedLicense,
+    hasKey: _hasLicenseKey
+  };
+}
+var NO_LICENSE_MESSAGE = "License key required. Get your key from the Exe OS team, then:\n\n  echo 'exe_sk_YOUR_KEY' > ~/.exe-os/license.key\n\nThen run /mcp to reconnect, or restart your session.";
+
+export {
+  initLicenseGate,
+  getCachedLicenseGate,
+  NO_LICENSE_MESSAGE
+};

package/dist/chunk-E2Q4Y22A.js

@@ -0,0 +1,86 @@
+import {
+  formatStatusAll,
+  formatStatusDeep,
+  getEmployeeStatuses,
+  inTmux,
+  init_tmux_status
+} from "./chunk-DC4ZD76Y.js";
+import {
+  fastDbInit
+} from "./chunk-CURJUF3W.js";
+import {
+  init_task_scope,
+  sessionScopeFilter
+} from "./chunk-N7L33TED.js";
+import {
+  getClient,
+  init_database
+} from "./chunk-A2NZP64U.js";
+import {
+  init_employees,
+  isCoordinatorRole,
+  loadEmployees
+} from "./chunk-RUG3N6P4.js";
+import {
+  isMainModule
+} from "./chunk-6Y4B3QF6.js";
+
+// src/bin/exe-status.ts
+init_employees();
+init_database();
+init_tmux_status();
+init_task_scope();
+async function status(targetEmployee) {
+  if (!inTmux()) {
+    return "Not in a tmux session. Start tmux first: tmux new-session -s work";
+  }
+  const employees = await loadEmployees();
+  const names = employees.filter((e) => !isCoordinatorRole(e.role)).map((e) => e.name);
+  const roles = new Map(employees.map((e) => [e.name, e.role ?? ""]));
+  await fastDbInit();
+  const client = getClient();
+  const taskMap = /* @__PURE__ */ new Map();
+  try {
+    const esScope = sessionScopeFilter();
+    const result = await client.execute({
+      sql: `SELECT assigned_to, title, priority FROM tasks
+            WHERE status = 'in_progress'${esScope.sql}
+            ORDER BY priority ASC, created_at ASC`,
+      args: [...esScope.args]
+    });
+    for (const row of result.rows) {
+      const assignee = String(row.assigned_to);
+      if (!taskMap.has(assignee)) {
+        taskMap.set(assignee, {
+          title: String(row.title),
+          priority: String(row.priority)
+        });
+      }
+    }
+  } catch {
+  }
+  if (targetEmployee) {
+    if (!names.includes(targetEmployee)) {
+      return `Employee "${targetEmployee}" not found. Available: ${names.join(", ")}`;
+    }
+    const statuses2 = getEmployeeStatuses([targetEmployee]);
+    const s = statuses2[0];
+    return formatStatusDeep(s, taskMap.get(targetEmployee), roles.get(targetEmployee) ?? "");
+  }
+  const statuses = getEmployeeStatuses(names);
+  return formatStatusAll(statuses, taskMap, roles);
+}
+if (isMainModule(import.meta.url)) {
+  const target = process.argv[2];
+  status(target).then((output) => {
+    process.stdout.write(output + "\n");
+  }).catch((err) => {
+    process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(1);
+  });
+}
+
+export {
+  status
+};

package/dist/chunk-ECGTESAP.js

@@ -0,0 +1,236 @@
+// src/lib/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  name;
+  defaultModel;
+  client;
+  constructor(name, config) {
+    this.name = name;
+    this.defaultModel = config.defaultModel ?? "claude-sonnet-4-20250514";
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl || void 0
+    });
+  }
+  async createMessage(params) {
+    const response = await this.client.messages.create({
+      model: params.model || this.defaultModel,
+      max_tokens: params.maxTokens,
+      system: params.system,
+      messages: params.messages.map((m) => this.toAnthropicMessage(m)),
+      tools: params.tools?.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.inputSchema
+      }))
+    });
+    return this.normalizeResponse(response);
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      await this.client.messages.create({
+        model: this.defaultModel,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }]
+      });
+      return { available: true, latencyMs: Date.now() - start };
+    } catch {
+      return { available: false, latencyMs: Date.now() - start };
+    }
+  }
+  toAnthropicMessage(msg) {
+    if (typeof msg.content === "string") {
+      return { role: msg.role, content: msg.content };
+    }
+    const blocks = msg.content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      if (block.type === "tool_result") {
+        return {
+          type: "tool_result",
+          tool_use_id: block.tool_use_id,
+          content: block.content,
+          is_error: block.is_error
+        };
+      }
+      return { type: "text", text: "" };
+    });
+    return { role: msg.role, content: blocks };
+  }
+  normalizeResponse(response) {
+    const content = response.content.map((block) => {
+      if (block.type === "text") {
+        return { type: "text", text: block.text };
+      }
+      if (block.type === "tool_use") {
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      }
+      return { type: "text", text: "" };
+    });
+    const stopReason = response.stop_reason === "tool_use" ? "tool_use" : response.stop_reason === "max_tokens" ? "max_tokens" : "end_turn";
+    return {
+      content,
+      stopReason,
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens
+      }
+    };
+  }
+};
+
+// src/lib/providers/openai-compat.ts
+import OpenAI from "openai";
+import { randomUUID } from "crypto";
+var OpenAICompatProvider = class {
+  name;
+  defaultModel;
+  client;
+  constructor(name, config) {
+    this.name = name;
+    this.defaultModel = config.defaultModel ?? "gpt-4o";
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+  }
+  async createMessage(params) {
+    const messages = [
+      { role: "system", content: params.system },
+      ...params.messages.flatMap((m) => this.toOpenAIMessages(m))
+    ];
+    const tools = params.tools?.map(
+      (t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.inputSchema
+        }
+      })
+    );
+    const response = await this.client.chat.completions.create({
+      model: params.model || this.defaultModel,
+      max_tokens: params.maxTokens,
+      messages,
+      tools: tools?.length ? tools : void 0
+    });
+    return this.normalizeResponse(response);
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      await this.client.chat.completions.create({
+        model: this.defaultModel,
+        max_tokens: 1,
+        messages: [{ role: "user", content: "hi" }]
+      });
+      return { available: true, latencyMs: Date.now() - start };
+    } catch {
+      return { available: false, latencyMs: Date.now() - start };
+    }
+  }
+  toOpenAIMessages(msg) {
+    if (typeof msg.content === "string") {
+      return [{ role: msg.role, content: msg.content }];
+    }
+    if (msg.role === "assistant") {
+      const textParts = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      const toolCalls = msg.content.filter((b) => b.type === "tool_use").map((b) => ({
+        id: b.id,
+        type: "function",
+        function: {
+          name: b.name,
+          arguments: typeof b.input === "string" ? b.input : JSON.stringify(b.input)
+        }
+      }));
+      if (toolCalls.length > 0) {
+        return [{
+          role: "assistant",
+          content: textParts || null,
+          tool_calls: toolCalls
+        }];
+      }
+      return [{ role: "assistant", content: textParts }];
+    }
+    if (msg.role === "user") {
+      const toolResults = msg.content.filter(
+        (b) => b.type === "tool_result"
+      );
+      if (toolResults.length > 0) {
+        return toolResults.map((r) => ({
+          role: "tool",
+          tool_call_id: r.tool_use_id,
+          content: r.content
+        }));
+      }
+      const text = msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      return [{ role: "user", content: text }];
+    }
+    return [{ role: msg.role, content: "" }];
+  }
+  normalizeResponse(response) {
+    const choice = response.choices[0];
+    if (!choice) {
+      return {
+        content: [{ type: "text", text: "" }],
+        stopReason: "end_turn",
+        usage: { inputTokens: 0, outputTokens: 0 }
+      };
+    }
+    const content = [];
+    if (choice.message.content) {
+      content.push({ type: "text", text: choice.message.content });
+    }
+    if (choice.message.tool_calls) {
+      for (const call of choice.message.tool_calls) {
+        const fn = call.function;
+        if (!fn) continue;
+        let input;
+        try {
+          input = JSON.parse(fn.arguments);
+        } catch {
+          input = fn.arguments;
+        }
+        content.push({
+          type: "tool_use",
+          id: call.id ?? randomUUID(),
+          name: fn.name,
+          input
+        });
+      }
+    }
+    if (content.length === 0) {
+      content.push({ type: "text", text: "" });
+    }
+    const stopReason = choice.finish_reason === "tool_calls" ? "tool_use" : choice.finish_reason === "length" ? "max_tokens" : "end_turn";
+    return {
+      content,
+      stopReason,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        outputTokens: response.usage?.completion_tokens ?? 0
+      }
+    };
+  }
+};
+
+export {
+  AnthropicProvider,
+  OpenAICompatProvider
+};