@phenx-inc/ctlsurf 0.3.13 → 0.3.14

package/bin/ctlsurf-worker.js

@@ -460,35 +460,51 @@ function ask(question) {
   })
 }
 
-// Persist a key to every worker settings.json profile + the shell rc.
-function persistKey(key) {
-  for (const p of allSettingsPaths()) {
-    const s = normalizeSettings(readSettings(p))
-    activeProfile(s).apiKey = key
-    writeSettings(p, s)
+// Export CTLSURF_API_KEY to the OS so MCP clients pick it up. On Windows
+// this is a persistent user env var (setx); elsewhere it's an export line
+// in the shell rc. Either way it applies to new shells, not the current one.
+function exportKeyToEnv(key) {
+  if (process.platform === 'win32') {
+    try {
+      execFileSync('setx', ['CTLSURF_API_KEY', key], { stdio: 'ignore' })
+      console.log(`  ${G}✓${R} Set CTLSURF_API_KEY (user environment)`)
+      console.log(`  ${D}Open a new terminal for the env var to apply.${R}`)
+    } catch {
+      console.log(`  ${Y}!${R} Could not run setx — set CTLSURF_API_KEY manually.`)
+    }
+    return
   }
-  console.log(`  ${G}✓${R} Saved to worker settings.`)
 
   const home = os.homedir()
   const rc = ['.zshrc', '.bashrc', '.bash_profile']
     .map((f) => path.join(home, f))
     .find((f) => fs.existsSync(f))
-  if (rc) {
-    try {
-      let content = fs.readFileSync(rc, 'utf-8')
-      content = content
-        .split('\n')
-        .filter((l) => !/^\s*export\s+CTLSURF_API_KEY=/.test(l))
-        .join('\n')
-      if (content && !content.endsWith('\n')) content += '\n'
-      content += `\n# ctlsurf worker API key\nexport CTLSURF_API_KEY="${key}"\n`
-      fs.writeFileSync(rc, content)
-      console.log(`  ${G}✓${R} Exported CTLSURF_API_KEY in ${rc}`)
-      console.log(`  ${D}Restart your shell or run: source ${rc}${R}`)
-    } catch {
-      console.log(`  ${Y}!${R} Could not update ${rc} — set CTLSURF_API_KEY manually.`)
-    }
+  if (!rc) return
+  try {
+    let content = fs.readFileSync(rc, 'utf-8')
+    content = content
+      .split('\n')
+      .filter((l) => !/^\s*export\s+CTLSURF_API_KEY=/.test(l))
+      .join('\n')
+    if (content && !content.endsWith('\n')) content += '\n'
+    content += `\n# ctlsurf worker API key\nexport CTLSURF_API_KEY="${key}"\n`
+    fs.writeFileSync(rc, content)
+    console.log(`  ${G}✓${R} Exported CTLSURF_API_KEY in ${rc}`)
+    console.log(`  ${D}Restart your shell or run: source ${rc}${R}`)
+  } catch {
+    console.log(`  ${Y}!${R} Could not update ${rc} — set CTLSURF_API_KEY manually.`)
   }
+}
+
+// Persist a key to every worker settings.json profile + the OS environment.
+function persistKey(key) {
+  for (const p of allSettingsPaths()) {
+    const s = normalizeSettings(readSettings(p))
+    activeProfile(s).apiKey = key
+    writeSettings(p, s)
+  }
+  console.log(`  ${G}✓${R} Saved to worker settings.`)
+  exportKeyToEnv(key)
   console.log('')
 }
 

package/out/headless/index.mjs

@@ -5471,7 +5471,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@phenx-inc/ctlsurf",
-      version: "0.3.13",
+      version: "0.3.14",
       description: "Agent-agnostic terminal and desktop app for ctlsurf \u2014 run Claude Code, Codex, or any coding agent with live session logging and remote control",
       main: "out/main/index.js",
       bin: {
@@ -5738,6 +5738,14 @@ var CtlsurfApi = class {
   async updateRow(blockId, rowId, data) {
     return this.request("PUT", `/datastore/${blockId}/rows/${rowId}`, { data });
   }
+  async queryRows(blockId, opts) {
+    const params = new URLSearchParams();
+    if (opts?.orderBy) params.set("order_by", opts.orderBy);
+    if (opts?.order) params.set("order", opts.order);
+    params.set("limit", String(opts?.limit ?? 200));
+    const qs = params.toString();
+    return this.request("GET", `/datastore/${blockId}/rows${qs ? `?${qs}` : ""}`);
+  }
   async getDatastoreSchema(blockId) {
     return this.request("GET", `/datastore/${blockId}/schema`);
   }
@@ -6607,6 +6615,213 @@ var TimeTracker = class {
   }
 };
 
+// src/main/ticketStore.ts
+var DATASTORE_TITLE2 = "Tickets";
+var AGENT_DATASTORE_PAGE_TITLE2 = "Agent Datastore";
+var SYSTEM_KEY2 = "tickets";
+var STATUS_OPTIONS = [
+  { value: "Open", color: "blue" },
+  { value: "In Progress", color: "yellow" },
+  { value: "Blocked", color: "red" },
+  { value: "Done", color: "green" }
+];
+var PRIORITY_OPTIONS = [
+  { value: "Low", color: "gray" },
+  { value: "Med", color: "yellow" },
+  { value: "High", color: "red" }
+];
+var COLUMNS2 = [
+  { name: "Title", type: "text" },
+  { name: "Description", type: "text" },
+  { name: "Status", type: "select", options: STATUS_OPTIONS },
+  { name: "Priority", type: "select", options: PRIORITY_OPTIONS },
+  { name: "Created", type: "date" }
+];
+function log3(...args) {
+  try {
+    console.log("[ticket-store]", ...args);
+  } catch {
+  }
+}
+function findPageByTitle2(pages, title) {
+  for (const p of pages) {
+    if (p?.title === title) return p;
+    if (p?.children?.length) {
+      const c = findPageByTitle2(p.children, title);
+      if (c) return c;
+    }
+  }
+  return null;
+}
+var TicketStore = class {
+  api;
+  blockCache = /* @__PURE__ */ new Map();
+  constructor(api) {
+    this.api = api;
+  }
+  /** Resolves (or creates) the project's Tickets datastore and appends a row. */
+  async addTicket(cwd, input) {
+    const title = input.title?.trim();
+    if (!title) return { ok: false, error: "Title is required" };
+    try {
+      const blockId = await this.ensureDatastore(cwd, true);
+      if (!blockId) {
+        return { ok: false, error: "No ctlsurf project found for this folder" };
+      }
+      await this.api.addRow(blockId, {
+        Title: title,
+        Description: input.description?.trim() || "",
+        Status: input.status || "Open",
+        Priority: input.priority || "Med",
+        Created: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      log3(`Added ticket "${title}" for ${cwd}`);
+      return { ok: true };
+    } catch (err) {
+      log3(`addTicket failed for ${cwd}: ${err?.message || err}`);
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  /** Updates an existing ticket row in the project's Tickets datastore. */
+  async updateTicket(cwd, rowId, input) {
+    const title = input.title?.trim();
+    if (!title) return { ok: false, error: "Title is required" };
+    try {
+      const blockId = await this.ensureDatastore(cwd, false);
+      if (!blockId) return { ok: false, error: "No Tickets datastore for this project" };
+      await this.api.updateRow(blockId, rowId, {
+        Title: title,
+        Description: input.description?.trim() || "",
+        Status: input.status || "Open",
+        Priority: input.priority || "Med"
+      });
+      log3(`Updated ticket ${rowId} for ${cwd}`);
+      return { ok: true };
+    } catch (err) {
+      log3(`updateTicket failed for ${cwd}: ${err?.message || err}`);
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  /** Lists existing tickets for the project, newest first. Does not create the
+   * datastore — an unconfigured project simply has no tickets yet. */
+  async listTickets(cwd) {
+    try {
+      const blockId = await this.ensureDatastore(cwd, false);
+      if (!blockId) return { ok: true, tickets: [] };
+      const res = await this.api.queryRows(blockId, { orderBy: "Created", order: "desc", limit: 200 });
+      const tickets = (res?.rows || []).map((r) => ({
+        id: r.id,
+        title: String(r.data?.Title ?? ""),
+        description: String(r.data?.Description ?? ""),
+        status: String(r.data?.Status ?? "Open"),
+        priority: String(r.data?.Priority ?? "Med"),
+        created: r.data?.Created ?? r.created_at ?? null
+      }));
+      return { ok: true, tickets };
+    } catch (err) {
+      log3(`listTickets failed for ${cwd}: ${err?.message || err}`);
+      return { ok: false, tickets: [], error: err?.message || String(err) };
+    }
+  }
+  async ensureDatastore(cwd, create) {
+    const cached = this.blockCache.get(cwd);
+    if (cached) return cached;
+    let folder = null;
+    try {
+      folder = await this.api.findFolderByPath(cwd);
+    } catch {
+      return null;
+    }
+    if (!folder?.id) return null;
+    const folderDetail = await this.api.getFolder(folder.id);
+    const agentPage = findPageByTitle2(folderDetail?.pages || [], AGENT_DATASTORE_PAGE_TITLE2);
+    if (!agentPage?.id) return null;
+    const blockId = await this.findOrAdoptBlock(agentPage.id);
+    if (blockId) {
+      await this.ensureColumns(blockId);
+      this.blockCache.set(cwd, blockId);
+      return blockId;
+    }
+    if (!create) return null;
+    const columns = COLUMNS2.map((c, i) => ({
+      id: `col_${i}`,
+      name: c.name,
+      type: c.type,
+      ...c.options ? { options: c.options } : {}
+    }));
+    const created = await this.api.createBlock(agentPage.id, {
+      type: "datastore",
+      title: DATASTORE_TITLE2,
+      props: { columns, system_key: SYSTEM_KEY2 }
+    });
+    if (created?.id) {
+      log3(`Created "${DATASTORE_TITLE2}" datastore on Agent Datastore page for ${cwd}`);
+      this.blockCache.set(cwd, created.id);
+      return created.id;
+    }
+    return null;
+  }
+  /** Finds an existing Tickets block on the page. Prefers a system_key match
+   * (which survives title renames). Falls back to title match for legacy blocks
+   * and backfills system_key on the way out. */
+  async findOrAdoptBlock(pageId) {
+    const summaries = await this.api.getPageBlockSummaries(pageId) || [];
+    const datastoreSummaries = summaries.filter((b) => b?.type === "datastore" && b?.id);
+    if (datastoreSummaries.length === 0) return null;
+    let titleFallbackId = null;
+    let titleFallbackProps = null;
+    for (const s of datastoreSummaries) {
+      try {
+        const block = await this.api.getBlock(s.id);
+        const props = block?.props || {};
+        if (props.system_key === SYSTEM_KEY2) {
+          return s.id;
+        }
+        if (s.title === DATASTORE_TITLE2 && titleFallbackId === null) {
+          titleFallbackId = s.id;
+          titleFallbackProps = props;
+        }
+      } catch (err) {
+        log3(`getBlock(${s.id}) failed during lookup: ${err?.message || err}`);
+      }
+    }
+    if (titleFallbackId) {
+      try {
+        await this.api.updateBlock(titleFallbackId, {
+          props: { ...titleFallbackProps || {}, system_key: SYSTEM_KEY2 }
+        });
+        log3(`Backfilled system_key on legacy Tickets block ${titleFallbackId}`);
+      } catch (err) {
+        log3(`backfill system_key failed on ${titleFallbackId}: ${err?.message || err}`);
+      }
+      return titleFallbackId;
+    }
+    return null;
+  }
+  async ensureColumns(blockId) {
+    try {
+      const schema = await this.api.getDatastoreSchema(blockId);
+      const existingCols = schema.columns || [];
+      const existingNames = new Set(existingCols.map((c) => c.name));
+      const missing = COLUMNS2.filter((c) => !existingNames.has(c.name));
+      if (missing.length === 0) return;
+      const usedIds = new Set(existingCols.map((c) => c.id));
+      let nextIdx = existingCols.length;
+      const appended = missing.map((c) => {
+        let id = `col_${nextIdx++}`;
+        while (usedIds.has(id)) id = `col_${nextIdx++}`;
+        usedIds.add(id);
+        return { id, name: c.name, type: c.type, ...c.options ? { options: c.options } : {} };
+      });
+      const merged = [...existingCols, ...appended];
+      await this.api.updateDatastoreSchema(blockId, merged);
+      log3(`Added ${missing.length} missing column(s) to existing Tickets datastore: ${missing.map((c) => c.name).join(", ")}`);
+    } catch (err) {
+      log3(`ensureColumns failed: ${err?.message || err}`);
+    }
+  }
+};
+
 // src/main/orchestrator.ts
 var DEFAULT_IDLE_TIMEOUT_MIN = 15;
 var DEFAULT_PROFILES = {
@@ -6629,6 +6844,7 @@ var Orchestrator = class {
   bridge = new ConversationBridge();
   workerWs;
   timeTracker = new TimeTracker(this.ctlsurfApi);
+  ticketStore = new TicketStore(this.ctlsurfApi);
   // State
   tabs = /* @__PURE__ */ new Map();
   activeTabId = null;
@@ -6977,6 +7193,36 @@ var Orchestrator = class {
       await this.timeTracker.endSession(this.activeTabId);
     }
   }
+  // ─── Tickets (active tab) ───────────────────────
+  /** cwd of the focused terminal tab, or null if no tab is active. */
+  getActiveTabCwd() {
+    if (!this.activeTabId) return null;
+    return this.tabs.get(this.activeTabId)?.cwd ?? null;
+  }
+  async addTicketForActiveTab(input) {
+    const cwd = this.getActiveTabCwd();
+    if (!cwd) return { ok: false, error: "No active terminal tab" };
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, error: "ctlsurf API key not configured" };
+    }
+    return this.ticketStore.addTicket(cwd, input);
+  }
+  async updateTicketForActiveTab(rowId, input) {
+    const cwd = this.getActiveTabCwd();
+    if (!cwd) return { ok: false, error: "No active terminal tab" };
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, error: "ctlsurf API key not configured" };
+    }
+    return this.ticketStore.updateTicket(cwd, rowId, input);
+  }
+  async listTicketsForActiveTab() {
+    const cwd = this.getActiveTabCwd();
+    if (!cwd) return { ok: false, tickets: [], error: "No active terminal tab" };
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, tickets: [], error: "ctlsurf API key not configured" };
+    }
+    return this.ticketStore.listTickets(cwd);
+  }
   // ─── Worker WebSocket ───────────────────────────
   connectWorkerWs(agent, cwd) {
     const profile = this.getActiveProfile();