@ceki/sdk 1.13.0 → 1.14.0

package/dist/index.cjs

@@ -41,19 +41,29 @@ __export(index_exports, {
   ChatSendFailed: () => ChatSendFailed,
   Client: () => Client,
   ConnectionLost: () => ConnectionLost,
+  ContractClient: () => ContractClient,
+  ContractError: () => ContractError,
   HumanProfile: () => HumanProfile,
   Humanizer: () => Humanizer,
   InsufficientFunds: () => InsufficientFunds,
   NotOwner: () => NotOwner,
   ProviderDisconnected: () => ProviderDisconnected,
   ProviderOffline: () => ProviderOffline,
+  ROLE_QA: () => ROLE_QA,
+  ROLE_REVIEWER: () => ROLE_REVIEWER,
   RateLimitExceeded: () => RateLimitExceeded,
   SessionEnded: () => SessionEnded,
   SessionExpired: () => SessionExpired,
   SessionNotFound: () => SessionNotFound,
+  TimelogClient: () => TimelogClient,
   TimeoutError: () => TimeoutError,
   TransportError: () => TransportError,
-  connect: () => connect
+  cleanArgs: () => cleanArgs,
+  connect: () => connect,
+  contractIdsFromEnv: () => contractIdsFromEnv,
+  deriveLabel: () => deriveLabel,
+  parseBenefitable: () => parseBenefitable,
+  parseParticipant: () => parseParticipant
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -2049,6 +2059,380 @@ var Client = class _Client {
 async function connect(apiKey, opts) {
   return Client.create(apiKey, opts);
 }
+
+// src/contract.ts
+var ROLE_REVIEWER = 5;
+var ROLE_QA = 6;
+var ContractError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ContractError";
+  }
+};
+function parseBenefitable(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const parts = String(value).split(":");
+  if (parts.length !== 2) {
+    throw new Error(`benefitable must be 'type:id', got: ${JSON.stringify(value)}`);
+  }
+  const [btype, bid] = parts;
+  const num = Number.parseInt(bid, 10);
+  if (!Number.isFinite(num) || Number.isNaN(num)) {
+    throw new Error(`benefitable id must be int, got: ${JSON.stringify(bid)}`);
+  }
+  return { type: btype, value: num };
+}
+function parseParticipant(value, roleId) {
+  const base = parseBenefitable(value);
+  if (base === null) return null;
+  return {
+    participable_id: base.value,
+    type: base.type,
+    role_id: roleId
+  };
+}
+function cleanArgs(o) {
+  const out = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== void 0 && v !== null) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function deriveLabel(desc) {
+  if (!desc) return "progress";
+  const lines = String(desc).split(/\r?\n/);
+  for (const ln of lines) {
+    const t = ln.trim();
+    if (t) return t.slice(0, 60);
+  }
+  return "progress";
+}
+function contractIdsFromEnv() {
+  const raw = (process.env.CEKI_CONTRACT_IDS ?? "").trim();
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed.map((x) => String(x));
+  } catch {
+  }
+  return raw.replace(/\[/g, "").replace(/\]/g, "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function resolveEndpoint() {
+  const override = process.env.CEKI_AGENT_MCP_ENDPOINT;
+  if (override) return override.replace(/\/+$/, "");
+  const base = (process.env.CEKI_API_URL ?? defaults.apiUrl).replace(/\/+$/, "");
+  return `${base}/mcp/agent`;
+}
+function resolveApiBase() {
+  const override = process.env.CEKI_API_BASE;
+  if (override) return override.replace(/\/+$/, "");
+  const base = (process.env.CEKI_API_URL ?? defaults.apiUrl).replace(/\/+$/, "");
+  return `${base}/api`;
+}
+function resolveToken() {
+  return process.env.CEKI_AGENT_TOKEN ?? process.env.CEKI_API_KEY ?? "";
+}
+var TOOL_MAP = {
+  list: "get-my-contracts",
+  members: "get-contract-members",
+  tasks: "get-contract-events",
+  "my-jobs": "get-my-jobs",
+  task: "get-event",
+  children: "get-event-children",
+  history: "get-event-history",
+  create: "create-contract-event",
+  comment: "comment",
+  propose: "propose-correction",
+  vote: "vote-correction"
+};
+var FetchHttpClient = class {
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs;
+  }
+  timeoutMs;
+  withTimeout() {
+    const ctl = new AbortController();
+    const t = setTimeout(() => ctl.abort(), this.timeoutMs);
+    return { signal: ctl.signal, cancel: () => clearTimeout(t) };
+  }
+  async post(url, init) {
+    const { signal, cancel } = this.withTimeout();
+    try {
+      const r = await fetch(url, { method: "POST", headers: init.headers, body: init.body, signal });
+      const text = await r.text();
+      return {
+        status: r.status,
+        text: async () => text,
+        json: async () => {
+          try {
+            return JSON.parse(text);
+          } catch {
+            return { raw: text };
+          }
+        }
+      };
+    } finally {
+      cancel();
+    }
+  }
+  async get(url, init) {
+    const { signal, cancel } = this.withTimeout();
+    try {
+      const r = await fetch(url, { method: "GET", headers: init.headers, signal });
+      const text = await r.text();
+      return {
+        status: r.status,
+        text: async () => text,
+        json: async () => {
+          try {
+            return JSON.parse(text);
+          } catch {
+            return { raw: text };
+          }
+        }
+      };
+    } finally {
+      cancel();
+    }
+  }
+};
+var ContractClient = class {
+  endpoint;
+  apiBase;
+  token;
+  http;
+  constructor(opts = {}) {
+    this.endpoint = (opts.endpoint ?? resolveEndpoint()).replace(/\/+$/, "");
+    this.apiBase = (opts.apiBase ?? resolveApiBase()).replace(/\/+$/, "");
+    this.token = opts.token !== void 0 ? opts.token : resolveToken();
+    this.http = opts.http ?? new FetchHttpClient(opts.timeoutMs ?? 3e4);
+  }
+  headers() {
+    if (!this.token) {
+      throw new ContractError("agent token not set (CEKI_AGENT_TOKEN or CEKI_API_KEY)");
+    }
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${this.token}`
+    };
+  }
+  async rpc(method, params) {
+    const body = JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method,
+      params
+    });
+    const resp = await this.http.post(this.endpoint, { headers: this.headers(), body });
+    let parsed;
+    try {
+      parsed = await resp.json();
+    } catch {
+      parsed = { raw: await resp.text() };
+    }
+    if (resp.status !== 200) {
+      const snippet = JSON.stringify(parsed).slice(0, 400);
+      throw new ContractError(`HTTP ${resp.status}: ${snippet}`);
+    }
+    return parsed ?? {};
+  }
+  /** Call MCP tool; unwrap content[].text (JSON-parsed) or structuredContent. */
+  async call(tool, args = {}) {
+    const body = await this.rpc("tools/call", { name: tool, arguments: args });
+    if (body["error"]) {
+      throw new ContractError(`${tool} \u2192 ${JSON.stringify(body["error"]).slice(0, 400)}`);
+    }
+    const result = body["result"] ?? {};
+    const content = result["content"];
+    if (Array.isArray(content)) {
+      const texts = content.filter((c) => c["type"] === "text").map((c) => String(c["text"] ?? ""));
+      const joined = texts.join("\n");
+      try {
+        return JSON.parse(joined);
+      } catch {
+        return joined;
+      }
+    }
+    if (result["structuredContent"] !== void 0) return result["structuredContent"];
+    return result;
+  }
+  async tools() {
+    const body = await this.rpc("tools/list", {});
+    const result = body["result"] ?? {};
+    const tools = result["tools"];
+    if (Array.isArray(tools)) return tools.map((t) => t["name"]);
+    return body;
+  }
+  async raw(tool, args = {}) {
+    return this.call(tool, args);
+  }
+  // ── domain helpers ──────────────────────────────────────────────
+  async listContracts() {
+    return this.call(TOOL_MAP.list, {});
+  }
+  async members(contractId) {
+    return this.call(TOOL_MAP.members, { contract_id: Number(contractId) });
+  }
+  async tasks(contractId) {
+    return this.call(TOOL_MAP.tasks, { contract_id: Number(contractId) });
+  }
+  async myJobs() {
+    return this.call(TOOL_MAP["my-jobs"], {});
+  }
+  async task(eventId) {
+    return this.call(TOOL_MAP.task, { event_id: Number(eventId) });
+  }
+  async children(eventId) {
+    return this.call(TOOL_MAP.children, { event_id: Number(eventId) });
+  }
+  async history(eventId, opts = {}) {
+    const args = cleanArgs({ event_id: Number(eventId), limit: opts.limit });
+    return this.call(TOOL_MAP.history, args);
+  }
+  async create(contractId, opts) {
+    const users = [];
+    const rev = parseParticipant(opts.reviewer, ROLE_REVIEWER);
+    if (rev !== null) users.push(rev);
+    const qa = parseParticipant(opts.qa, ROLE_QA);
+    if (qa !== null) users.push(qa);
+    if (opts.participants && opts.participants.length) {
+      users.push(...opts.participants);
+    }
+    const args = cleanArgs({
+      contract_id: Number(contractId),
+      label: opts.label,
+      type_id: opts.type,
+      status_id: opts.status,
+      kal_schedule_id: opts.kalScheduleId,
+      start: opts.start,
+      end: opts.end,
+      timezone: opts.timezone,
+      date: opts.date,
+      duration: opts.duration,
+      amount: opts.amount,
+      currency: opts.currency,
+      description: opts.description,
+      data: opts.data,
+      benefitable: opts.benefitable !== void 0 ? parseBenefitable(opts.benefitable) : void 0,
+      users: users.length > 0 ? users : void 0
+    });
+    return this.call(TOOL_MAP.create, args);
+  }
+  async comment(eventId, opts = {}) {
+    const args = cleanArgs({
+      event_id: Number(eventId),
+      label: opts.label,
+      type_id: opts.type,
+      status_id: opts.status,
+      start: opts.start,
+      end: opts.end,
+      date: opts.date,
+      duration: opts.duration,
+      amount: opts.amount,
+      currency: opts.currency,
+      description: opts.description,
+      benefitable: opts.benefitable !== void 0 ? parseBenefitable(opts.benefitable) : void 0
+    });
+    return this.call(TOOL_MAP.comment, args);
+  }
+  async propose(eventId, opts = {}) {
+    const args = cleanArgs({
+      event_id: Number(eventId),
+      status_id: opts.status,
+      label: opts.label,
+      description: opts.description,
+      start: opts.start,
+      end: opts.end,
+      date: opts.date,
+      duration: opts.duration,
+      amount: opts.amount,
+      currency: opts.currency,
+      benefitable: opts.benefitable !== void 0 ? parseBenefitable(opts.benefitable) : void 0
+    });
+    return this.call(TOOL_MAP.propose, args);
+  }
+  /** Status correction (optional) + progress comment in one shot.
+   *
+   * The event's own description is NOT touched. `desc` becomes the
+   * body of a child comment-event, not a label/description overwrite
+   * on the parent event. Use this for Hand/QA/Reviewer progress
+   * reports — `propose --desc` would clobber the parent spec.
+   */
+  async progress(eventId, opts) {
+    let statusResult = null;
+    if (opts.status !== void 0 && opts.status !== null) {
+      statusResult = await this.propose(eventId, { status: Number(opts.status) });
+    }
+    const label = deriveLabel(opts.desc);
+    const commentResult = await this.comment(eventId, { label, description: opts.desc });
+    return { status_correction: statusResult, comment: commentResult };
+  }
+  async vote(eventId, ids, vote) {
+    return this.call(TOOL_MAP.vote, {
+      event_id: Number(eventId),
+      ids: ids.map((i) => Number(i)),
+      vote: Boolean(vote)
+    });
+  }
+  // ── polling (REST, not MCP) ────────────────────────────────────
+  /** GET /agent/polling. Returns [] on 429 (rate-limit, 10/min/token). */
+  async poll() {
+    const resp = await this.http.get(`${this.apiBase}/agent/polling`, {
+      headers: { Accept: "application/json", Authorization: `Bearer ${this.token}` }
+    });
+    if (resp.status === 429) return [];
+    if (resp.status !== 200) {
+      let body2;
+      try {
+        body2 = await resp.json();
+      } catch {
+        body2 = await resp.text();
+      }
+      throw new ContractError(`polling HTTP ${resp.status}: ${JSON.stringify(body2).slice(0, 300)}`);
+    }
+    const body = await resp.json();
+    if (Array.isArray(body)) return body;
+    if (body && typeof body === "object") {
+      const obj = body;
+      for (const k of ["notifications", "data", "items"]) {
+        const v = obj[k];
+        if (Array.isArray(v)) return v;
+      }
+    }
+    return [];
+  }
+};
+
+// src/timelog.ts
+var TOOL_MAP2 = {
+  start: "timelog-start",
+  stop: "timelog-stop",
+  check: "timelog-check"
+};
+var TimelogClient = class {
+  c;
+  constructor(opts = {}) {
+    if (opts.contract) {
+      this.c = opts.contract;
+    } else {
+      this.c = new ContractClient(opts);
+    }
+  }
+  async start(eventId) {
+    return this.c.call(TOOL_MAP2.start, { event_id: Number(eventId) });
+  }
+  async stop(eventId, label) {
+    const args = { event_id: Number(eventId) };
+    if (label !== void 0 && label !== null) args["label"] = label;
+    return this.c.call(TOOL_MAP2.stop, args);
+  }
+  async check(eventId) {
+    return this.c.call(TOOL_MAP2.check, { event_id: Number(eventId) });
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthError,
@@ -2062,18 +2446,28 @@ async function connect(apiKey, opts) {
   ChatSendFailed,
   Client,
   ConnectionLost,
+  ContractClient,
+  ContractError,
   HumanProfile,
   Humanizer,
   InsufficientFunds,
   NotOwner,
   ProviderDisconnected,
   ProviderOffline,
+  ROLE_QA,
+  ROLE_REVIEWER,
   RateLimitExceeded,
   SessionEnded,
   SessionExpired,
   SessionNotFound,
+  TimelogClient,
   TimeoutError,
   TransportError,
-  connect
+  cleanArgs,
+  connect,
+  contractIdsFromEnv,
+  deriveLabel,
+  parseBenefitable,
+  parseParticipant
 });
 //# sourceMappingURL=index.cjs.map