@ceki/sdk 1.13.0 → 1.14.0

package/dist/cli.js

@@ -472,8 +472,8 @@ function saveSession(sid, data) {
 function deleteSession(sid) {
   try {
     fs2.unlinkSync(statePath(sid));
-  } catch (err2) {
-    if (err2.code !== "ENOENT") throw err2;
+  } catch (err3) {
+    if (err3.code !== "ENOENT") throw err3;
   }
 }
 function getLastSeenTs(sid) {
@@ -1189,10 +1189,10 @@ var Browser = class _Browser {
   _onChatSendError(msg) {
     this.chat._onSendError(msg);
   }
-  _rejectAllPending(err2) {
+  _rejectAllPending(err3) {
     for (const [id, pending] of this._pendingCdp) {
       clearTimeout(pending.timer);
-      pending.reject(err2);
+      pending.reject(err3);
     }
     this._pendingCdp.clear();
   }
@@ -1604,9 +1604,9 @@ var Client = class _Client {
       this._stopHeartbeat();
       const reasonStr = reason.toString();
       if (code === 4401 || code === 4403) {
-        const err2 = new AuthError(reasonStr || `Auth failed (${code})`);
+        const err3 = new AuthError(reasonStr || `Auth failed (${code})`);
         if (this._connectReject) {
-          this._connectReject(err2);
+          this._connectReject(err3);
           this._connectResolve = null;
           this._connectReject = null;
         }
@@ -1616,9 +1616,9 @@ var Client = class _Client {
         this._scheduleReconnect();
       }
     });
-    this._ws.on("error", (err2) => {
+    this._ws.on("error", (err3) => {
       if (this._connectReject) {
-        this._connectReject(new TransportError(err2.message));
+        this._connectReject(new TransportError(err3.message));
         this._connectResolve = null;
         this._connectReject = null;
       }
@@ -1637,8 +1637,8 @@ var Client = class _Client {
   _scheduleReconnect() {
     if (this._closed || this._reconnecting) return;
     if (this._reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
-      const err2 = new ConnectionLost("Max reconnection attempts exceeded");
-      this._rejectAllPending(err2);
+      const err3 = new ConnectionLost("Max reconnection attempts exceeded");
+      this._rejectAllPending(err3);
       return;
     }
     this._reconnecting = true;
@@ -1929,44 +1929,44 @@ var Client = class _Client {
         }
       }
     }
-    let err2;
+    let err3;
     switch (code) {
       case -1012:
-        err2 = new InsufficientFunds(reason);
-        this._rejectAllPending(err2);
+        err3 = new InsufficientFunds(reason);
+        this._rejectAllPending(err3);
         break;
       case -1013:
-        err2 = new RateLimitExceeded(0, reason);
-        this._rejectAllPending(err2);
+        err3 = new RateLimitExceeded(0, reason);
+        this._rejectAllPending(err3);
         break;
       case -1015:
-        err2 = new ProviderOffline(reason);
-        this._rejectFirstPendingRent(err2);
+        err3 = new ProviderOffline(reason);
+        this._rejectFirstPendingRent(err3);
         break;
       default:
-        err2 = new CekiBrowserError(reason || `relay error ${code}`);
-        this._rejectFirstPendingRent(err2);
+        err3 = new CekiBrowserError(reason || `relay error ${code}`);
+        this._rejectFirstPendingRent(err3);
         break;
     }
   }
-  _rejectFirstPendingRent(err2) {
+  _rejectFirstPendingRent(err3) {
     const eventId = this._pendingRents.keys().next().value;
     if (eventId != null) {
       const pending = this._pendingRents.get(eventId);
       clearTimeout(pending.timer);
       this._pendingRents.delete(eventId);
-      pending.reject(err2);
+      pending.reject(err3);
     }
   }
-  _rejectAllPending(err2) {
+  _rejectAllPending(err3) {
     for (const [key, pending] of this._pendingRents) {
       clearTimeout(pending.timer);
-      pending.reject(err2);
+      pending.reject(err3);
     }
     this._pendingRents.clear();
     for (const [key, pending] of this._pendingResumes) {
       clearTimeout(pending.timer);
-      pending.reject(err2);
+      pending.reject(err3);
     }
     this._pendingResumes.clear();
   }
@@ -1990,17 +1990,796 @@ async function connect(apiKey, opts) {
   return Client.create(apiKey, opts);
 }
 
-// src/cli.ts
+// 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 out3 = {};
+  for (const [k, v] of Object.entries(o)) {
+    if (v !== void 0 && v !== null) {
+      out3[k] = v;
+    }
+  }
+  return out3;
+}
+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) });
+  }
+};
+
+// src/contract-cli.ts
 function out(data) {
+  if (typeof data === "string") {
+    process.stdout.write(data + "\n");
+  } else {
+    process.stdout.write(JSON.stringify(data, null, 2) + "\n");
+  }
+}
+function err(message, code = "error") {
+  process.stderr.write(JSON.stringify({ error: message, code }) + "\n");
+}
+function parseParticipantSpec(spec) {
+  if (!spec || typeof spec !== "string") {
+    throw new Error(`--participant must be a non-empty string, got: ${JSON.stringify(spec)}`);
+  }
+  const parts = spec.split(":");
+  if (parts.length < 3) {
+    throw new Error(
+      `--participant must be 'type:id:role' (e.g. agent:5:reviewer), got: ${JSON.stringify(spec)}`
+    );
+  }
+  const [ptype, pid, role, ...rest] = parts;
+  if (ptype !== "agent" && ptype !== "user") {
+    throw new Error(`--participant type must be 'agent' or 'user', got: ${JSON.stringify(ptype)}`);
+  }
+  const value = Number.parseInt(pid, 10);
+  if (!Number.isFinite(value) || Number.isNaN(value)) {
+    throw new Error(`--participant id must be int, got: ${JSON.stringify(pid)}`);
+  }
+  const roleMap = { reviewer: ROLE_REVIEWER, qa: ROLE_QA };
+  let roleId;
+  if (role in roleMap) {
+    roleId = roleMap[role];
+  } else if (role === "role") {
+    if (rest.length === 0) {
+      throw new Error(`--participant 'role:NUMBER' needs a number, got: ${JSON.stringify(spec)}`);
+    }
+    const n = Number.parseInt(rest[0], 10);
+    if (!Number.isFinite(n) || Number.isNaN(n)) {
+      throw new Error(`--participant role id must be int, got: ${JSON.stringify(rest[0])}`);
+    }
+    roleId = n;
+  } else {
+    throw new Error(
+      `--participant unknown role ${JSON.stringify(role)}; expected 'reviewer', 'qa', or 'role:NUMBER'`
+    );
+  }
+  return { participable_id: value, type: ptype, role_id: roleId };
+}
+function parseArgs(argv) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const name = a.slice(2);
+      const next = argv[i + 1];
+      if (next === void 0 || next.startsWith("--")) {
+        flags[name] = true;
+      } else {
+        if (flags[name] !== void 0) {
+          const cur = flags[name];
+          if (Array.isArray(cur)) cur.push(next);
+          else flags[name] = [cur, next];
+        } else {
+          flags[name] = next;
+        }
+        i++;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { positional, flags };
+}
+function flagStr(args, key) {
+  const v = args.flags[key];
+  if (v === void 0 || v === true) return void 0;
+  if (Array.isArray(v)) return v[v.length - 1];
+  return v;
+}
+function flagInt(args, key) {
+  const v = flagStr(args, key);
+  if (v === void 0) return void 0;
+  const n = Number.parseInt(v, 10);
+  if (Number.isNaN(n)) throw new Error(`--${key} must be int, got: ${JSON.stringify(v)}`);
+  return n;
+}
+function flagList(args, key) {
+  const v = args.flags[key];
+  if (v === void 0) return [];
+  if (v === true) return [];
+  if (Array.isArray(v)) return v;
+  return [v];
+}
+function requireFlag(args, key) {
+  const v = flagStr(args, key);
+  if (v === void 0) throw new Error(`--${key} is required`);
+  return v;
+}
+function dump(value) {
+  out(value);
+}
+var contractClientFactory = () => new ContractClient();
+var timelogClientFactory = () => new TimelogClient();
+async function cmdContract(argv) {
+  const action = argv[0];
+  if (!action) {
+    err("contract: subcommand required", "args");
+    return 1;
+  }
+  const rest = argv.slice(1);
+  const args = parseArgs(rest);
+  const client = contractClientFactory();
+  try {
+    switch (action) {
+      case "list": {
+        dump(await client.listContracts());
+        return 0;
+      }
+      case "members": {
+        const cid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(cid)) {
+          err("contract members: cid required", "args");
+          return 1;
+        }
+        dump(await client.members(cid));
+        return 0;
+      }
+      case "tasks": {
+        const explicit = args.positional[0];
+        const ids = explicit !== void 0 ? [explicit] : contractIdsFromEnv();
+        if (ids.length === 0) {
+          err("no contract id (positional or CEKI_CONTRACT_IDS)", "args");
+          return 1;
+        }
+        for (const cid of ids) {
+          process.stdout.write(`--- contract ${cid} ---
+`);
+          dump(await client.tasks(Number(cid)));
+        }
+        return 0;
+      }
+      case "my-jobs": {
+        dump(await client.myJobs());
+        return 0;
+      }
+      case "task": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract task: eid required", "args");
+          return 1;
+        }
+        dump(await client.task(eid));
+        return 0;
+      }
+      case "children": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract children: eid required", "args");
+          return 1;
+        }
+        dump(await client.children(eid));
+        return 0;
+      }
+      case "history": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract history: eid required", "args");
+          return 1;
+        }
+        dump(await client.history(eid, { limit: flagInt(args, "limit") }));
+        return 0;
+      }
+      case "create": {
+        const explicit = args.positional[0];
+        let cid;
+        if (explicit !== void 0) {
+          cid = Number.parseInt(explicit, 10);
+        } else {
+          const envIds = contractIdsFromEnv();
+          if (envIds.length === 0) {
+            err("contract id required (positional or CEKI_CONTRACT_IDS)", "args");
+            return 1;
+          }
+          cid = Number.parseInt(envIds[0], 10);
+        }
+        if (Number.isNaN(cid)) {
+          err("contract create: cid must be int", "args");
+          return 1;
+        }
+        const label = requireFlag(args, "label");
+        const dataRaw = flagStr(args, "data");
+        const dataObj = dataRaw ? JSON.parse(dataRaw) : void 0;
+        let extras = [];
+        try {
+          extras = flagList(args, "participant").map(parseParticipantSpec);
+        } catch (e) {
+          err(e.message, "args");
+          return 1;
+        }
+        dump(
+          await client.create(cid, {
+            label,
+            type: flagInt(args, "type"),
+            status: flagInt(args, "status"),
+            kalScheduleId: flagInt(args, "kal-schedule"),
+            start: flagStr(args, "start"),
+            end: flagStr(args, "end"),
+            timezone: flagStr(args, "timezone"),
+            date: flagStr(args, "date"),
+            duration: flagInt(args, "duration"),
+            amount: flagInt(args, "amount"),
+            currency: flagStr(args, "currency"),
+            description: flagStr(args, "desc"),
+            data: dataObj,
+            benefitable: flagStr(args, "benefitable"),
+            reviewer: flagStr(args, "reviewer"),
+            qa: flagStr(args, "qa"),
+            participants: extras.length > 0 ? extras : void 0
+          })
+        );
+        return 0;
+      }
+      case "comment": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract comment: eid required", "args");
+          return 1;
+        }
+        dump(
+          await client.comment(eid, {
+            label: flagStr(args, "label"),
+            type: flagInt(args, "type"),
+            status: flagInt(args, "status"),
+            start: flagStr(args, "start"),
+            end: flagStr(args, "end"),
+            date: flagStr(args, "date"),
+            duration: flagInt(args, "duration"),
+            amount: flagInt(args, "amount"),
+            currency: flagStr(args, "currency"),
+            description: flagStr(args, "desc"),
+            benefitable: flagStr(args, "benefitable")
+          })
+        );
+        return 0;
+      }
+      case "propose": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract propose: eid required", "args");
+          return 1;
+        }
+        dump(
+          await client.propose(eid, {
+            status: flagInt(args, "status"),
+            label: flagStr(args, "label"),
+            description: flagStr(args, "desc"),
+            start: flagStr(args, "start"),
+            end: flagStr(args, "end"),
+            date: flagStr(args, "date"),
+            duration: flagInt(args, "duration"),
+            amount: flagInt(args, "amount"),
+            currency: flagStr(args, "currency"),
+            benefitable: flagStr(args, "benefitable")
+          })
+        );
+        return 0;
+      }
+      case "progress": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract progress: eid required", "args");
+          return 1;
+        }
+        const desc = flagStr(args, "desc");
+        if (desc === void 0) {
+          err("contract progress: --desc is required", "args");
+          return 1;
+        }
+        dump(
+          await client.progress(eid, {
+            status: flagInt(args, "status"),
+            desc
+          })
+        );
+        return 0;
+      }
+      case "vote": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("contract vote: eid required", "args");
+          return 1;
+        }
+        const idsRaw = requireFlag(args, "ids");
+        const voteRaw = requireFlag(args, "vote");
+        const ids = idsRaw.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => Number.parseInt(s, 10));
+        const vote = ["true", "1", "yes"].includes(voteRaw.toLowerCase());
+        dump(await client.vote(eid, ids, vote));
+        return 0;
+      }
+      case "poll": {
+        const items = await client.poll();
+        dump({ count: items.length, notifications: items });
+        return 0;
+      }
+      case "watch": {
+        const interval = Math.max(6, Number.parseInt(args.positional[0] ?? "8", 10) || 8);
+        process.stderr.write(
+          `[watch] poll every ${interval}s (limit 10/min/token; do not go below 6s)
+`
+        );
+        while (true) {
+          const items = await client.poll();
+          if (items.length > 0) {
+            const ts = (/* @__PURE__ */ new Date()).toISOString();
+            for (const n of items) {
+              process.stdout.write(JSON.stringify({ ts, notification: n }) + "\n");
+            }
+          }
+          await new Promise((r) => setTimeout(r, interval * 1e3));
+        }
+      }
+      case "tools": {
+        dump(await client.tools());
+        return 0;
+      }
+      case "raw": {
+        const tool = args.positional[0];
+        if (!tool) {
+          err("contract raw: tool name required", "args");
+          return 1;
+        }
+        const payloadRaw = args.positional[1] ?? "{}";
+        const payload = JSON.parse(payloadRaw);
+        dump(await client.raw(tool, payload));
+        return 0;
+      }
+      default: {
+        err(`unknown contract action: ${action}`, "args");
+        return 1;
+      }
+    }
+  } catch (e) {
+    if (e instanceof ContractError) {
+      err(e.message, "contract");
+      return 1;
+    }
+    err(e.message ?? String(e), "error");
+    return 1;
+  }
+}
+async function cmdTimelog(argv) {
+  const action = argv[0];
+  if (!action) {
+    err("timelog: subcommand required", "args");
+    return 1;
+  }
+  const rest = argv.slice(1);
+  const args = parseArgs(rest);
+  const client = timelogClientFactory();
+  try {
+    switch (action) {
+      case "start": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("timelog start: event_id required", "args");
+          return 1;
+        }
+        dump(await client.start(eid));
+        return 0;
+      }
+      case "stop": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("timelog stop: event_id required", "args");
+          return 1;
+        }
+        dump(await client.stop(eid, flagStr(args, "label")));
+        return 0;
+      }
+      case "check": {
+        const eid = Number.parseInt(args.positional[0] ?? "", 10);
+        if (Number.isNaN(eid)) {
+          err("timelog check: event_id required", "args");
+          return 1;
+        }
+        dump(await client.check(eid));
+        return 0;
+      }
+      default: {
+        err(`unknown timelog action: ${action}`, "args");
+        return 1;
+      }
+    }
+  } catch (e) {
+    if (e instanceof ContractError) {
+      err(e.message, "timelog");
+      return 1;
+    }
+    err(e.message ?? String(e), "error");
+    return 1;
+  }
+}
+
+// src/cli.ts
+function out2(data) {
   process.stdout.write(JSON.stringify(data) + "\n");
 }
-function err(error, code = "error") {
+function err2(error, code = "error") {
   process.stderr.write(JSON.stringify({ error, code }) + "\n");
 }
 function getApiKey() {
   const key = process.env.CEKI_API_KEY;
   if (!key) {
-    err("CEKI_API_KEY not set", "auth");
+    err2("CEKI_API_KEY not set", "auth");
     process.exit(2);
   }
   return key;
@@ -2032,14 +2811,14 @@ async function cmdRent(args) {
     if (args[i] === "--mode" && args[i + 1]) {
       const v = args[++i];
       if (v !== "incognito" && v !== "main") {
-        err("invalid mode, must be incognito or main", "args");
+        err2("invalid mode, must be incognito or main", "args");
         process.exit(1);
       }
       mode = v;
     }
   }
   if (scheduleId == null) {
-    err("--schedule is required", "args");
+    err2("--schedule is required", "args");
     process.exit(1);
   }
   const apiKey = getApiKey();
@@ -2057,7 +2836,7 @@ async function cmdRent(args) {
       schedule_id: browser.scheduleId,
       last_seen_ts: null
     });
-    out({
+    out2({
       session_id: browser.sessionId,
       chat_topic_id: browser.chatTopicId,
       schedule_id: browser.scheduleId
@@ -2080,7 +2859,7 @@ async function cmdSearch(args) {
   const client = await connect(apiKey, connectOptions());
   try {
     const results = await client.search(filters, limit);
-    out(results);
+    out2(results);
   } finally {
     await closeClient(client);
   }
@@ -2099,7 +2878,7 @@ async function cmdSessions(args) {
   try {
     const results = await client.listSessions({ active: !showAll, limit });
     if (jsonOutput) {
-      out(results);
+      out2(results);
     } else {
       if (!results.length) {
         process.stdout.write("No sessions found.\n");
@@ -2128,7 +2907,7 @@ async function cmdMyBrowsers() {
   const client = await connect(apiKey, connectOptions());
   try {
     const results = await client.myBrowsers();
-    out(results);
+    out2(results);
   } finally {
     await closeClient(client);
   }
@@ -2139,7 +2918,7 @@ async function cmdSnapshot(sid, args) {
     if ((args[i] === "-o" || args[i] === "--output") && args[i + 1]) outputPath = args[++i];
   }
   if (!outputPath) {
-    err("-o/--output is required", "args");
+    err2("-o/--output is required", "args");
     process.exit(1);
   }
   const apiKey = getApiKey();
@@ -2158,7 +2937,7 @@ async function cmdSnapshot(sid, args) {
       text: m.text,
       ts: m.created_at
     }));
-    out({ screenshot: outputPath, chat: chatList, ts: snap.ts.toISOString() });
+    out2({ screenshot: outputPath, chat: chatList, ts: snap.ts.toISOString() });
   } finally {
     await closeClient(client);
   }
@@ -2169,7 +2948,7 @@ function parseNoHuman(args) {
 async function cmdNavigate(sid, args) {
   const url = args.find((a) => !a.startsWith("--"));
   if (!url) {
-    err("URL is required", "args");
+    err2("URL is required", "args");
     process.exit(1);
   }
   const raw = parseNoHuman(args);
@@ -2177,7 +2956,7 @@ async function cmdNavigate(sid, args) {
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     await browser.navigate(url, 3e4, raw ? { human: false } : void 0);
-    out({ ok: true });
+    out2({ ok: true });
   } finally {
     await closeClient(client);
   }
@@ -2187,7 +2966,7 @@ async function cmdClick(sid, args) {
   const x = parseInt(positional[0], 10);
   const y = parseInt(positional[1], 10);
   if (isNaN(x) || isNaN(y)) {
-    err("x and y coordinates are required", "args");
+    err2("x and y coordinates are required", "args");
     process.exit(1);
   }
   const raw = parseNoHuman(args);
@@ -2195,7 +2974,7 @@ async function cmdClick(sid, args) {
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     await browser.click(x, y, raw ? { human: false } : void 0);
-    out({ ok: true, pointer: [x, y] });
+    out2({ ok: true, pointer: [x, y] });
   } finally {
     await closeClient(client);
   }
@@ -2209,7 +2988,7 @@ async function cmdType(sid, args) {
     } else if (!text) text = args[i];
   }
   if (!text) {
-    err("text is required", "args");
+    err2("text is required", "args");
     process.exit(1);
   }
   const apiKey = getApiKey();
@@ -2217,7 +2996,7 @@ async function cmdType(sid, args) {
   try {
     const browser = await client.resume(sid);
     await browser.type(text, raw ? { human: false } : void 0);
-    out({ ok: true });
+    out2({ ok: true });
   } finally {
     await closeClient(client);
   }
@@ -2228,7 +3007,7 @@ async function cmdScroll(sid, args) {
   const y = parseInt(positional[1], 10);
   const dy = parseInt(positional[2], 10);
   if (isNaN(x) || isNaN(y) || isNaN(dy)) {
-    err("x, y, dy are required", "args");
+    err2("x, y, dy are required", "args");
     process.exit(1);
   }
   const raw = parseNoHuman(args);
@@ -2238,7 +3017,7 @@ async function cmdScroll(sid, args) {
     const scrollOpts = { x, y, deltaY: dy };
     if (raw) scrollOpts.human = false;
     await browser.scroll(scrollOpts);
-    out({ ok: true });
+    out2({ ok: true });
   } finally {
     await closeClient(client);
   }
@@ -2251,11 +3030,11 @@ async function cmdChat(sid, action, args) {
       case "send": {
         const text = args[0];
         if (!text) {
-          err("text is required", "args");
+          err2("text is required", "args");
           process.exit(1);
         }
         const result = await browser.chat.send(text);
-        out({ ok: true, message_id: result.messageId });
+        out2({ ok: true, message_id: result.messageId });
         break;
       }
       case "send-image": {
@@ -2266,14 +3045,14 @@ async function cmdChat(sid, action, args) {
           if (args[i] === "--text" && args[i + 1]) text = args[++i];
         }
         if (!imagePath) {
-          err("--image is required", "args");
+          err2("--image is required", "args");
           process.exit(1);
         }
         if (text) {
           await browser.chat.send(text);
         }
         const result = await browser.chat.sendImage(imagePath);
-        out({ ok: true, message_id: result.messageId });
+        out2({ ok: true, message_id: result.messageId });
         break;
       }
       case "next": {
@@ -2286,7 +3065,7 @@ async function cmdChat(sid, action, args) {
         if (msgs.length > 0) {
           const m = msgs[0];
           updateLastSeenTs(sid, m.created_at);
-          out({ from: m.sender_id, text: m.text, ts: m.created_at });
+          out2({ from: m.sender_id, text: m.text, ts: m.created_at });
         } else {
           let resolved = false;
           const waitPromise = new Promise((resolve2) => {
@@ -2307,9 +3086,9 @@ async function cmdChat(sid, action, args) {
           const msg = await waitPromise;
           if (msg) {
             updateLastSeenTs(sid, msg.created_at);
-            out({ from: msg.sender_id, text: msg.text, ts: msg.created_at });
+            out2({ from: msg.sender_id, text: msg.text, ts: msg.created_at });
           } else {
-            out(null);
+            out2(null);
           }
         }
         break;
@@ -2330,11 +3109,11 @@ async function cmdChat(sid, action, args) {
           if (args[i] === "--limit" && args[i + 1]) limit = parseInt(args[++i], 10);
         }
         const msgs = await browser.chat.history({ since, limit });
-        out(msgs.map((m) => ({ from: m.sender_id, text: m.text, ts: m.created_at })));
+        out2(msgs.map((m) => ({ from: m.sender_id, text: m.text, ts: m.created_at })));
         break;
       }
       default:
-        err(`Unknown chat action: ${action}`, "args");
+        err2(`Unknown chat action: ${action}`, "args");
         process.exit(1);
     }
   } finally {
@@ -2347,7 +3126,7 @@ async function cmdStop(sid) {
   try {
     await browser.close();
     deleteSession(sid);
-    out({ ok: true });
+    out2({ ok: true });
   } finally {
     await closeClient(client);
   }
@@ -2367,7 +3146,7 @@ async function cmdProfile(sid, action, args) {
           if (args[i] === "--no-session-storage") noSessionStorage = true;
         }
         if (!outputPath) {
-          err("-o/--output is required", "args");
+          err2("-o/--output is required", "args");
           process.exit(1);
         }
         const profile = await browser.profile.export({
@@ -2375,7 +3154,7 @@ async function cmdProfile(sid, action, args) {
           includeSessionStorage: !noSessionStorage
         });
         fs4.writeFileSync(outputPath, JSON.stringify(profile, null, 2), "utf-8");
-        out({ ok: true, path: outputPath });
+        out2({ ok: true, path: outputPath });
         break;
       }
       case "import": {
@@ -2384,16 +3163,16 @@ async function cmdProfile(sid, action, args) {
           if ((args[i] === "-i" || args[i] === "--input") && args[i + 1]) inputPath = args[++i];
         }
         if (!inputPath) {
-          err("-i/--input is required", "args");
+          err2("-i/--input is required", "args");
           process.exit(1);
         }
         const profileData = JSON.parse(fs4.readFileSync(inputPath, "utf-8"));
         await browser.profile.import(profileData);
-        out({ ok: true });
+        out2({ ok: true });
         break;
       }
       default:
-        err(`Unknown profile action: ${action}`, "args");
+        err2(`Unknown profile action: ${action}`, "args");
         process.exit(1);
     }
   } finally {
@@ -2405,7 +3184,7 @@ async function cmdWait(sid) {
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     const reason = await browser.waitUntilEnded();
-    out({ ended: true, reason });
+    out2({ ended: true, reason });
   } finally {
     await closeClient(client);
   }
@@ -2418,7 +3197,7 @@ async function cmdScreenshot(sid, args) {
     if (args[i] === "--full") fullPage = true;
   }
   if (!outputPath) {
-    err("-o/--output is required", "args");
+    err2("-o/--output is required", "args");
     process.exit(1);
   }
   const apiKey = getApiKey();
@@ -2426,7 +3205,7 @@ async function cmdScreenshot(sid, args) {
   try {
     const data = await browser.screenshot({ format: "png", fullPage });
     fs4.writeFileSync(outputPath, data);
-    out({ ok: true, path: outputPath });
+    out2({ ok: true, path: outputPath });
   } finally {
     await closeClient(client);
   }
@@ -2436,7 +3215,7 @@ async function cmdSwitchTab(sid) {
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     await browser.switchTab();
-    out({ ok: true });
+    out2({ ok: true });
   } finally {
     await closeClient(client);
   }
@@ -2451,7 +3230,7 @@ async function cmdConfigure(sid, args) {
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     await browser.configure(opts);
-    out({ ok: true });
+    out2({ ok: true });
   } finally {
     await closeClient(client);
   }
@@ -2464,14 +3243,14 @@ async function cmdCdp(sid, args) {
     if (args[i] === "--params" && args[i + 1]) params = JSON.parse(args[++i]);
   }
   if (!method) {
-    err("--method is required", "args");
+    err2("--method is required", "args");
     process.exit(1);
   }
   const apiKey = getApiKey();
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     const result = await browser.send({ method, params });
-    out(result);
+    out2(result);
   } finally {
     await closeClient(client);
   }
@@ -2493,7 +3272,7 @@ async function cmdRequestCaptcha(sid, args) {
       completionTimeout: completion,
       autoAccept: !manual
     });
-    out({
+    out2({
       solved: result.solved,
       proof_message_id: result.proofMessageId,
       cancel_reason: result.cancelReason,
@@ -2503,7 +3282,7 @@ async function cmdRequestCaptcha(sid, args) {
     if (!result.solved) process.exit(1);
   } catch (e) {
     if (e instanceof CaptchaTimeoutError) {
-      out({ solved: false, cancel_reason: `timeout:${e.phase}`, child_event_id: null, correction_id: null });
+      out2({ solved: false, cancel_reason: `timeout:${e.phase}`, child_event_id: null, correction_id: null });
       process.exit(1);
     }
     throw e;
@@ -2523,18 +3302,18 @@ async function cmdUpload(sid, args) {
     if (args[i] === "--mime" && args[i + 1]) mime2 = args[++i];
   }
   if (!selector || !filePath) {
-    err("--selector and --file are required", "args");
+    err2("--selector and --file are required", "args");
     process.exit(1);
   }
   if (!fs4.existsSync(filePath)) {
-    err(`File not found: ${filePath}`, "args");
+    err2(`File not found: ${filePath}`, "args");
     process.exit(1);
   }
   const apiKey = getApiKey();
   const [client, browser] = await resumeBrowser(apiKey, sid);
   try {
     const result = await browser.upload(selector, filePath, filename, mime2);
-    out(result);
+    out2(result);
   } finally {
     await closeClient(client);
   }
@@ -2568,12 +3347,46 @@ Commands:
   profile import <sid> -i file
   stop <sid>
 
+  contract list
+  contract members <cid>
+  contract tasks [cid]                (default: CEKI_CONTRACT_IDS)
+  contract my-jobs
+  contract task <eid>
+  contract children <eid>
+  contract history <eid> [--limit N]
+  contract create [cid] --label X [--type N] [--status N] [--kal-schedule N]
+                       [--start S] [--end E] [--timezone TZ] [--date D]
+                       [--duration N] [--amount N] [--currency C]
+                       [--benefitable agent:N|user:N]
+                       [--reviewer agent:N|user:N] [--qa agent:N|user:N]
+                       [--participant agent:N:reviewer|user:N:qa|agent:N:role:NUM]...
+                       [--desc text] [--data JSON]
+  contract comment <eid> [--label X] [--type N] [--status N] [--start S]
+                          [--end E] [--date D] [--duration N] [--amount N]
+                          [--currency C] [--benefitable agent:N] [--desc text]
+  contract propose <eid> [--status N] [--label X] [--desc text] [--start S]
+                          [--end E] [--date D] [--duration N] [--amount N]
+                          [--currency C] [--benefitable agent:N]
+  contract progress <eid> [--status N] --desc TEXT
+  contract vote <eid> --ids 1,2,3 --vote true|false
+  contract poll
+  contract watch [interval]
+  contract tools
+  contract raw <tool> [JSON]
+
+  timelog start <event_id>
+  timelog stop <event_id> [--label TEXT]
+  timelog check <event_id>
+
 Environment:
   CEKI_API_KEY (required)
   CEKI_RELAY_URL (default: wss://browser.ceki.me/ws/agent)
   CEKI_API_URL (default: https://api.ceki.me)
   CEKI_CHAT_URL (default: https://chat.ceki.me/api/chat)
   CEKI_BASIC_AUTH_USER / CEKI_BASIC_AUTH_PASS (optional)
+  CEKI_AGENT_TOKEN (contract/timelog; falls back to CEKI_API_KEY)
+  CEKI_AGENT_MCP_ENDPOINT (override /mcp/agent endpoint)
+  CEKI_CONTRACT_IDS (default contract for 'contract tasks'/'create')
 
 Exit codes: 0=success, 1=error, 2=auth, 3=session_not_found, 4=timeout, 5=network`);
 }
@@ -2595,6 +3408,12 @@ async function main() {
   }
   const command = argv[0];
   const rest = argv.slice(1);
+  if (command === "contract") {
+    process.exit(await cmdContract(rest));
+  }
+  if (command === "timelog") {
+    process.exit(await cmdTimelog(rest));
+  }
   switch (command) {
     case "rent":
       await cmdRent(rest);
@@ -2649,45 +3468,45 @@ async function main() {
       break;
     case "chat":
       if (rest.length < 2) {
-        err("Usage: ceki chat <sid> <action> [args]", "args");
+        err2("Usage: ceki chat <sid> <action> [args]", "args");
         process.exit(1);
       }
       await cmdChat(rest[0], rest[1], rest.slice(2));
       break;
     case "profile":
       if (rest.length < 2) {
-        err("Usage: ceki profile export|import <sid> [args]", "args");
+        err2("Usage: ceki profile export|import <sid> [args]", "args");
         process.exit(1);
       }
       await cmdProfile(rest[1], rest[0], rest.slice(2));
       break;
     default:
-      err(`Unknown command: ${command}`, "args");
+      err2(`Unknown command: ${command}`, "args");
       process.exit(1);
   }
 }
 main().catch((e) => {
   if (e instanceof SessionExpired || e instanceof SessionNotFound) {
-    err(String(e), "session_not_found");
+    err2(String(e), "session_not_found");
     process.exit(3);
   }
   if (e instanceof NotOwner) {
-    err(String(e), "not_owner");
+    err2(String(e), "not_owner");
     process.exit(3);
   }
   if (e instanceof TimeoutError) {
-    err(String(e), "timeout");
+    err2(String(e), "timeout");
     process.exit(4);
   }
   if (e instanceof ConnectionLost || e instanceof AuthError || e instanceof TransportError) {
-    err(String(e), "network");
+    err2(String(e), "network");
     process.exit(5);
   }
   if (e instanceof CekiBrowserError) {
-    err(String(e), "ceki_error");
+    err2(String(e), "ceki_error");
     process.exit(1);
   }
-  err(e instanceof Error ? e.message : String(e), "error");
+  err2(e instanceof Error ? e.message : String(e), "error");
   process.exit(1);
 });
 //# sourceMappingURL=cli.js.map