openclaw-codex-app-server 0.0.0

package/src/state.test.ts

@@ -0,0 +1,228 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { describe, expect, it } from "vitest";
+import { PluginStateStore, buildPluginSessionKey } from "./state.js";
+
+async function makeStoreDir(): Promise<string> {
+  return await fs.mkdtemp(path.join(os.tmpdir(), "oc-codex-plugin-"));
+}
+
+async function makeStore(dir?: string): Promise<PluginStateStore> {
+  const resolvedDir = dir ?? (await makeStoreDir());
+  const store = new PluginStateStore(resolvedDir);
+  await store.load();
+  return store;
+}
+
+describe("state store", () => {
+  it("persists bindings and callbacks", async () => {
+    const dir = await makeStoreDir();
+    const store = await makeStore(dir);
+    await store.upsertPendingBind({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "124",
+      },
+      threadId: "thread-pending",
+      workspaceDir: "/tmp/pending",
+      threadTitle: "Pending thread",
+      updatedAt: Date.now(),
+    });
+    await store.upsertBinding({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      sessionKey: buildPluginSessionKey("thread-1"),
+      threadId: "thread-1",
+      workspaceDir: "/tmp/work",
+      contextUsage: {
+        totalTokens: 9_800,
+        contextWindow: 258_000,
+        remainingPercent: 96,
+      },
+      updatedAt: Date.now(),
+    });
+    const callback = await store.putCallback({
+      kind: "resume-thread",
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/tmp/work",
+      syncTopic: true,
+    });
+    const promptCallback = await store.putCallback({
+      kind: "run-prompt",
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      prompt: "Implement the plan.",
+      workspaceDir: "/tmp/work",
+      collaborationMode: {
+        mode: "default",
+        settings: {
+          model: "openai/gpt-5.4",
+          developerInstructions: null,
+        },
+      },
+    });
+    const modelCallback = await store.putCallback({
+      kind: "set-model",
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      model: "gpt-5.2-codex",
+    });
+    const replyCallback = await store.putCallback({
+      kind: "reply-text",
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      text: "Okay. Staying in plan mode.",
+    });
+    const reloaded = await makeStore(dir);
+
+    expect(reloaded.listBindings()).toHaveLength(1);
+    expect(reloaded.listBindings()[0]?.contextUsage?.totalTokens).toBe(9_800);
+    expect(reloaded.getPendingBind({
+      channel: "telegram",
+      accountId: "default",
+      conversationId: "124",
+    })?.threadId).toBe("thread-pending");
+    expect(reloaded.getCallback(callback.token)?.kind).toBe("resume-thread");
+    const resumeCallback = reloaded.getCallback(callback.token);
+    expect(resumeCallback?.kind).toBe("resume-thread");
+    expect(resumeCallback && resumeCallback.kind === "resume-thread" ? resumeCallback.syncTopic : undefined).toBe(true);
+    expect(reloaded.getCallback(promptCallback.token)?.kind).toBe("run-prompt");
+    const runPrompt = reloaded.getCallback(promptCallback.token);
+    expect(runPrompt && runPrompt.kind === "run-prompt" ? runPrompt.collaborationMode : undefined).toEqual({
+      mode: "default",
+      settings: {
+        model: "openai/gpt-5.4",
+        developerInstructions: null,
+      },
+    });
+    expect(reloaded.getCallback(modelCallback.token)?.kind).toBe("set-model");
+    expect(reloaded.getCallback(replyCallback.token)?.kind).toBe("reply-text");
+  });
+
+  it("removes pending requests and related callbacks", async () => {
+    const store = await makeStore();
+    await store.upsertPendingRequest({
+      requestId: "req-1",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "chan-1",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/tmp/work",
+      state: {
+        requestId: "req-1",
+        options: ["yes"],
+        expiresAt: Date.now() + 10_000,
+      },
+      updatedAt: Date.now(),
+    });
+    const callback = await store.putCallback({
+      kind: "pending-input",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "chan-1",
+      },
+      requestId: "req-1",
+      actionIndex: 0,
+    });
+    const questionnaireCallback = await store.putCallback({
+      kind: "pending-questionnaire",
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "chan-1",
+      },
+      requestId: "req-1",
+      questionIndex: 0,
+      action: "select",
+      optionIndex: 0,
+    });
+    await store.removePendingRequest("req-1");
+    expect(store.getPendingRequestById("req-1")).toBeNull();
+    expect(store.getCallback(callback.token)).toBeNull();
+    expect(store.getCallback(questionnaireCallback.token)).toBeNull();
+  });
+
+  it("clears a pending bind when the binding is finalized", async () => {
+    const store = await makeStore();
+    await store.upsertPendingBind({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "user:1",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/tmp/work",
+      updatedAt: Date.now(),
+    });
+
+    await store.upsertBinding({
+      conversation: {
+        channel: "discord",
+        accountId: "default",
+        conversationId: "user:1",
+      },
+      sessionKey: buildPluginSessionKey("thread-1"),
+      threadId: "thread-1",
+      workspaceDir: "/tmp/work",
+      updatedAt: Date.now(),
+    });
+
+    expect(
+      store.getPendingBind({
+        channel: "discord",
+        accountId: "default",
+        conversationId: "user:1",
+      }),
+    ).toBeNull();
+  });
+
+  it("clears a pending bind when the conversation is explicitly removed", async () => {
+    const store = await makeStore();
+    await store.upsertPendingBind({
+      conversation: {
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      },
+      threadId: "thread-1",
+      workspaceDir: "/tmp/work",
+      updatedAt: Date.now(),
+    });
+
+    await store.removeBinding({
+      channel: "telegram",
+      accountId: "default",
+      conversationId: "123",
+    });
+
+    expect(
+      store.getPendingBind({
+        channel: "telegram",
+        accountId: "default",
+        conversationId: "123",
+      }),
+    ).toBeNull();
+  });
+});

package/src/state.ts

@@ -0,0 +1,354 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { CALLBACK_TTL_MS, CALLBACK_TOKEN_BYTES, PLUGIN_ID, STORE_VERSION } from "./types.js";
+import type {
+  CallbackAction,
+  CollaborationMode,
+  ConversationTarget,
+  StoreSnapshot,
+  StoredBinding,
+  StoredPendingBind,
+  StoredPendingRequest,
+} from "./types.js";
+
+type PutCallbackInput =
+  | {
+      kind: "resume-thread";
+      conversation: ConversationTarget;
+      threadId: string;
+      workspaceDir: string;
+      syncTopic?: boolean;
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "pending-input";
+      conversation: ConversationTarget;
+      requestId: string;
+      actionIndex: number;
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "pending-questionnaire";
+      conversation: ConversationTarget;
+      requestId: string;
+      questionIndex: number;
+      action: "select" | "prev" | "next" | "freeform";
+      optionIndex?: number;
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "picker-view";
+      conversation: ConversationTarget;
+      view: Extract<CallbackAction, { kind: "picker-view" }>["view"];
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "run-prompt";
+      conversation: ConversationTarget;
+      prompt: string;
+      workspaceDir?: string;
+      collaborationMode?: CollaborationMode;
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "rename-thread";
+      conversation: ConversationTarget;
+      style: "thread-project" | "thread";
+      syncTopic: boolean;
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "set-model";
+      conversation: ConversationTarget;
+      model: string;
+      token?: string;
+      ttlMs?: number;
+    }
+  | {
+      kind: "reply-text";
+      conversation: ConversationTarget;
+      text: string;
+      token?: string;
+      ttlMs?: number;
+    };
+
+function toConversationKey(target: ConversationTarget): string {
+  const channel = target.channel.trim().toLowerCase();
+  return [
+    channel,
+    target.accountId.trim(),
+    target.conversationId.trim(),
+    channel === "telegram" ? (target.parentConversationId?.trim() ?? "") : "",
+  ].join("::");
+}
+
+function cloneSnapshot(value?: Partial<StoreSnapshot>): StoreSnapshot {
+  return {
+    version: STORE_VERSION,
+    bindings: value?.bindings ?? [],
+    pendingBinds: value?.pendingBinds ?? [],
+    pendingRequests: value?.pendingRequests ?? [],
+    callbacks: value?.callbacks ?? [],
+  };
+}
+
+export class PluginStateStore {
+  private snapshot = cloneSnapshot();
+
+  constructor(private readonly rootDir: string) {}
+
+  get dir(): string {
+    return path.join(this.rootDir, PLUGIN_ID);
+  }
+
+  get filePath(): string {
+    return path.join(this.dir, "state.json");
+  }
+
+  async load(): Promise<void> {
+    await fs.mkdir(this.dir, { recursive: true });
+    try {
+      const raw = await fs.readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw) as Partial<StoreSnapshot>;
+      this.snapshot = cloneSnapshot(parsed);
+      this.pruneExpired();
+      await this.save();
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw error;
+      }
+      this.snapshot = cloneSnapshot();
+      await this.save();
+    }
+  }
+
+  async save(): Promise<void> {
+    await fs.mkdir(this.dir, { recursive: true });
+    await fs.writeFile(this.filePath, `${JSON.stringify(this.snapshot, null, 2)}\n`, "utf8");
+  }
+
+  pruneExpired(now = Date.now()): void {
+    this.snapshot.pendingBinds = this.snapshot.pendingBinds.filter(
+      (entry) => now - entry.updatedAt < CALLBACK_TTL_MS,
+    );
+    this.snapshot.pendingRequests = this.snapshot.pendingRequests.filter(
+      (entry) => entry.state.expiresAt > now,
+    );
+    this.snapshot.callbacks = this.snapshot.callbacks.filter((entry) => entry.expiresAt > now);
+  }
+
+  listBindings(): StoredBinding[] {
+    return [...this.snapshot.bindings];
+  }
+
+  getBinding(target: ConversationTarget): StoredBinding | null {
+    const key = toConversationKey(target);
+    return this.snapshot.bindings.find((entry) => toConversationKey(entry.conversation) === key) ?? null;
+  }
+
+  async upsertBinding(binding: StoredBinding): Promise<void> {
+    const key = toConversationKey(binding.conversation);
+    this.snapshot.bindings = this.snapshot.bindings.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    this.snapshot.pendingBinds = this.snapshot.pendingBinds.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    this.snapshot.bindings.push(binding);
+    await this.save();
+  }
+
+  async removeBinding(target: ConversationTarget): Promise<void> {
+    const key = toConversationKey(target);
+    this.snapshot.bindings = this.snapshot.bindings.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    this.snapshot.pendingBinds = this.snapshot.pendingBinds.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    this.snapshot.pendingRequests = this.snapshot.pendingRequests.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    this.snapshot.callbacks = this.snapshot.callbacks.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    await this.save();
+  }
+
+  getPendingRequestByConversation(target: ConversationTarget): StoredPendingRequest | null {
+    const key = toConversationKey(target);
+    return (
+      this.snapshot.pendingRequests.find((entry) => toConversationKey(entry.conversation) === key) ??
+      null
+    );
+  }
+
+  getPendingBind(target: ConversationTarget): StoredPendingBind | null {
+    const key = toConversationKey(target);
+    return (
+      this.snapshot.pendingBinds.find((entry) => toConversationKey(entry.conversation) === key) ??
+      null
+    );
+  }
+
+  async upsertPendingBind(entry: StoredPendingBind): Promise<void> {
+    const key = toConversationKey(entry.conversation);
+    this.snapshot.pendingBinds = this.snapshot.pendingBinds.filter(
+      (current) => toConversationKey(current.conversation) !== key,
+    );
+    this.snapshot.pendingBinds.push(entry);
+    await this.save();
+  }
+
+  async removePendingBind(target: ConversationTarget): Promise<void> {
+    const key = toConversationKey(target);
+    this.snapshot.pendingBinds = this.snapshot.pendingBinds.filter(
+      (entry) => toConversationKey(entry.conversation) !== key,
+    );
+    await this.save();
+  }
+
+  getPendingRequestById(requestId: string): StoredPendingRequest | null {
+    return this.snapshot.pendingRequests.find((entry) => entry.requestId === requestId) ?? null;
+  }
+
+  async upsertPendingRequest(entry: StoredPendingRequest): Promise<void> {
+    this.snapshot.pendingRequests = this.snapshot.pendingRequests.filter(
+      (current) => current.requestId !== entry.requestId,
+    );
+    this.snapshot.pendingRequests.push(entry);
+    await this.save();
+  }
+
+  async removePendingRequest(requestId: string): Promise<void> {
+    this.snapshot.pendingRequests = this.snapshot.pendingRequests.filter(
+      (entry) => entry.requestId !== requestId,
+    );
+    this.snapshot.callbacks = this.snapshot.callbacks.filter((entry) => {
+      if (entry.kind !== "pending-input" && entry.kind !== "pending-questionnaire") {
+        return true;
+      }
+      return entry.requestId !== requestId;
+    });
+    await this.save();
+  }
+
+  createCallbackToken(): string {
+    return crypto.randomBytes(CALLBACK_TOKEN_BYTES).toString("base64url");
+  }
+
+  async putCallback(callback: PutCallbackInput): Promise<CallbackAction> {
+    const now = Date.now();
+    const entry: CallbackAction =
+      callback.kind === "resume-thread"
+        ? {
+            kind: "resume-thread",
+            conversation: callback.conversation,
+            threadId: callback.threadId,
+            workspaceDir: callback.workspaceDir,
+            syncTopic: callback.syncTopic,
+            token: callback.token ?? this.createCallbackToken(),
+            createdAt: now,
+            expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+          }
+        : callback.kind === "pending-input"
+          ? {
+              kind: "pending-input",
+              conversation: callback.conversation,
+              requestId: callback.requestId,
+              actionIndex: callback.actionIndex,
+              token: callback.token ?? this.createCallbackToken(),
+              createdAt: now,
+              expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+            }
+          : callback.kind === "pending-questionnaire"
+            ? {
+                kind: "pending-questionnaire",
+                conversation: callback.conversation,
+                requestId: callback.requestId,
+                questionIndex: callback.questionIndex,
+                action: callback.action,
+                optionIndex: callback.optionIndex,
+                token: callback.token ?? this.createCallbackToken(),
+                createdAt: now,
+                expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+              }
+          : callback.kind === "picker-view"
+            ? {
+              kind: "picker-view",
+              conversation: callback.conversation,
+              view: callback.view,
+              token: callback.token ?? this.createCallbackToken(),
+              createdAt: now,
+              expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+              }
+              : callback.kind === "run-prompt"
+                ? {
+                    kind: "run-prompt",
+                    conversation: callback.conversation,
+                    prompt: callback.prompt,
+                  workspaceDir: callback.workspaceDir,
+                  collaborationMode: callback.collaborationMode,
+                  token: callback.token ?? this.createCallbackToken(),
+                  createdAt: now,
+                  expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+                }
+              : callback.kind === "rename-thread"
+                ? {
+                    kind: "rename-thread",
+                    conversation: callback.conversation,
+                    style: callback.style,
+                    syncTopic: callback.syncTopic,
+                    token: callback.token ?? this.createCallbackToken(),
+                    createdAt: now,
+                    expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+                  }
+              : callback.kind === "set-model"
+                ? {
+                    kind: "set-model",
+                    conversation: callback.conversation,
+                    model: callback.model,
+                  token: callback.token ?? this.createCallbackToken(),
+                  createdAt: now,
+                  expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+                  }
+                : {
+                    kind: "reply-text",
+                    conversation: callback.conversation,
+                    text: callback.text,
+                    token: callback.token ?? this.createCallbackToken(),
+                    createdAt: now,
+                    expiresAt: now + (callback.ttlMs ?? CALLBACK_TTL_MS),
+                };
+    this.snapshot.callbacks = this.snapshot.callbacks.filter(
+      (current) => current.token !== entry.token,
+    );
+    this.snapshot.callbacks.push(entry);
+    await this.save();
+    return entry;
+  }
+
+  getCallback(token: string): CallbackAction | null {
+    return this.snapshot.callbacks.find((entry) => entry.token === token) ?? null;
+  }
+
+  async removeCallback(token: string): Promise<void> {
+    this.snapshot.callbacks = this.snapshot.callbacks.filter((entry) => entry.token !== token);
+    await this.save();
+  }
+}
+
+export function buildPluginSessionKey(threadId: string): string {
+  return `${PLUGIN_ID}:thread:${threadId.trim()}`;
+}
+
+export function buildConversationKey(target: ConversationTarget): string {
+  return toConversationKey(target);
+}

package/src/thread-picker.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import {
+  getProjectName,
+  listProjects,
+  paginateItems,
+} from "./thread-picker.js";
+
+describe("thread picker helpers", () => {
+  it("derives the project name from a worktree path", () => {
+    expect(getProjectName("/Users/huntharo/.codex/worktrees/cb00/openclaw")).toBe("openclaw");
+  });
+
+  it("groups multiple worktrees under the same project name", () => {
+    expect(
+      listProjects([
+        {
+          threadId: "1",
+          title: "One",
+          projectKey: "/Users/huntharo/.codex/worktrees/cb00/openclaw",
+          updatedAt: 10,
+        },
+        {
+          threadId: "2",
+          title: "Two",
+          projectKey: "/Users/huntharo/.codex/worktrees/cb01/openclaw",
+          updatedAt: 20,
+        },
+        {
+          threadId: "3",
+          title: "Three",
+          projectKey: "/Users/huntharo/github/gitcrawl",
+          updatedAt: 5,
+        },
+      ]),
+    ).toEqual([
+      { name: "openclaw", threadCount: 2, latestUpdatedAt: 20 },
+      { name: "gitcrawl", threadCount: 1, latestUpdatedAt: 5 },
+    ]);
+  });
+
+  it("paginates thread pickers without skipping items", () => {
+    const page = paginateItems(["a", "b", "c", "d", "e"], 1, 2);
+    expect(page.items).toEqual(["c", "d"]);
+    expect(page.page).toBe(1);
+    expect(page.totalPages).toBe(3);
+  });
+});