@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-provider-session-commands.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const root = __dirname;
+const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-session-commands-"));
+const workspace = path.join(configDir, "workspace");
+fs.mkdirSync(path.join(workspace, "alpha"), { recursive: true });
+fs.mkdirSync(path.join(workspace, "beta"), { recursive: true });
+process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
+process.env.WORKSPACE = workspace;
+process.env.TELEGRAM_CHAT_ID = "fixture";
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.CLAUDE_PATH = process.execPath;
+process.env.CODEX_PATH = process.execPath;
+
+const stateApi = require("./core/state");
+const handlers = require("./core/handlers");
+const commands = require("./core/commands");
+const { runInChat } = require("./core/context");
+
+function seedMatrix(state) {
+  const user = state.userId;
+  for (const [project, provider, session, model, effort] of [
+    ["alpha", "claude", "claude-alpha", "claude-alpha-model", "high"],
+    ["alpha", "codex", "codex-alpha", "codex-alpha-model", "low"],
+    ["beta", "claude", "claude-beta", "claude-beta-model", "medium"],
+    ["beta", "codex", "codex-beta", "codex-beta-model", "xhigh"],
+  ]) {
+    stateApi.recordSession(user, project, provider, session, `${provider} ${project}`, { strict: true });
+    stateApi.setProviderSession(state, provider, project, session);
+    const settings = stateApi.getProviderSettings(state, provider);
+    // Provider settings are provider-scoped rather than project-scoped. The
+    // final assignment for each provider is what switching must restore.
+    settings.model = model;
+    settings.effort = effort;
+  }
+}
+
+function switchingAndProjectProbe() {
+  const state = stateApi.currentState();
+  state.currentSession = { name: "alpha", dir: path.join(workspace, "alpha") };
+  state.settings.backend = "claude";
+  seedMatrix(state);
+  stateApi.getProviderSettings(state, "claude").model = "claude-restored";
+  stateApi.getProviderSettings(state, "claude").effort = "high";
+  stateApi.getProviderSettings(state, "codex").model = "codex-restored";
+  stateApi.getProviderSettings(state, "codex").effort = "low";
+
+  let switched = handlers.switchProviderState("codex", { state, persist: false });
+  assert.strictEqual(switched.ok, true);
+  assert.strictEqual(state.settings.backend, "codex");
+  assert.strictEqual(state.settings.model, "codex-restored");
+  assert.strictEqual(state.settings.effort, "low");
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), "codex-alpha");
+
+  switched = handlers.switchProviderState("claude", { state, persist: false });
+  assert.strictEqual(switched.ok, true);
+  assert.strictEqual(state.settings.model, "claude-restored");
+  assert.strictEqual(state.settings.effort, "high");
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), "codex-alpha", "Codex pointer survives Claude switch");
+
+  state.settings.backend = "codex";
+  handlers.selectProjectState({ name: "beta", dir: path.join(workspace, "beta") }, { state, persist: false });
+  assert.strictEqual(state.currentSession.name, "beta");
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "beta"), "codex-beta");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "beta"), "claude-beta");
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), "codex-alpha");
+}
+
+function newEndAndContinueProbe() {
+  const state = stateApi.currentState();
+  state.currentSession = { name: "alpha", dir: path.join(workspace, "alpha") };
+  state.settings.backend = "codex";
+  const settled = [];
+  state.messageQueue = [{ deferred: { resolve: (value) => settled.push(value) } }];
+
+  const fresh = handlers.startNewConversation({ state, persist: false });
+  assert.strictEqual(fresh.ok, true);
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), null);
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "claude-alpha");
+  assert.strictEqual(stateApi.userOwnsProviderSession(state.userId, "alpha", "codex", "codex-alpha"), true, "new does not delete history");
+  assert.strictEqual(state.messageQueue.length, 0);
+  assert.strictEqual(settled.length, 1);
+  assert.strictEqual(settled[0].status, "cancelled");
+
+  stateApi.setProviderSession(state, "codex", "alpha", "codex-alpha");
+  const continueOptions = handlers.activeContinueOptions(state);
+  assert.deepStrictEqual(continueOptions, { provider: "codex", resumeSessionId: "codex-alpha" });
+
+  const ended = handlers.endCurrentSession({ state, persist: false });
+  assert.strictEqual(ended.ok, true);
+  assert.strictEqual(state.currentSession, null);
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "alpha"), "codex-alpha");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "claude-alpha");
+  assert.strictEqual(stateApi.userOwnsProviderSession(state.userId, "alpha", "codex", "codex-alpha"), true);
+}
+
+function restartProbe() {
+  const state = stateApi.currentState();
+  state.currentSession = { name: "beta", dir: path.join(workspace, "beta") };
+  state.settings.backend = "codex";
+  stateApi.getProviderSettings(state, "claude").model = "claude-restored";
+  stateApi.getProviderSettings(state, "codex").model = "codex-restored";
+  stateApi.saveState({ strict: true });
+
+  const child = spawnSync(process.execPath, ["-e", [
+    "const s = require('./core/state');",
+    "const state = s.currentState();",
+    "process.stdout.write(JSON.stringify({",
+    "  project: state.currentSession.name,",
+    "  provider: s.getActiveProvider(state),",
+    "  alphaClaude: s.getProviderSession(state, 'claude', 'alpha'),",
+    "  alphaCodex: s.getProviderSession(state, 'codex', 'alpha'),",
+    "  betaClaude: s.getProviderSession(state, 'claude', 'beta'),",
+    "  betaCodex: s.getProviderSession(state, 'codex', 'beta'),",
+    "  claudeModel: s.getProviderSettings(state, 'claude').model,",
+    "  codexModel: s.getProviderSettings(state, 'codex').model,",
+    "}));",
+  ].join("\n")], { cwd: root, env: process.env, encoding: "utf8" });
+  assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+  assert.deepStrictEqual(JSON.parse(child.stdout), {
+    project: "beta",
+    provider: "codex",
+    alphaClaude: "claude-alpha",
+    alphaCodex: "codex-alpha",
+    betaClaude: "claude-beta",
+    betaCodex: "codex-beta",
+    claudeModel: "claude-restored",
+    codexModel: "codex-restored",
+  });
+}
+
+function commandRegistrationProbe() {
+  const names = new Set(commands.list().map((command) => command.name));
+  for (const name of ["new", "end", "continue", "backend", "claude", "codex"]) assert.ok(names.has(name), `/${name} registered`);
+  const source = fs.readFileSync(path.join(root, "core", "handlers.js"), "utf8");
+  assert.match(source, /name: "claude"[\s\S]*switchProviderCommand\(env, "claude"/);
+  assert.match(source, /name: "codex"[\s\S]*switchProviderCommand\(env, "codex"/);
+  assert.match(source, /name: "continue"[\s\S]*activeContinueOptions/);
+  const actions = fs.readFileSync(path.join(root, "core", "actions.js"), "utf8");
+  assert.match(actions, /switchProviderState/);
+  assert.match(actions, /startNewConversation/);
+  assert.match(actions, /endCurrentSession/);
+}
+
+async function removedProviderSelectionProbe() {
+  const state = stateApi.currentState();
+  state.currentSession = null;
+  state.settings.backend = null;
+  const sent = [];
+  await runInChat({
+    adapter: {
+      type: "fixture",
+      send: async (_channelId, text) => { sent.push(text); return true; },
+    },
+    channelId: "fixture",
+    canonicalUserId: state.userId,
+    userId: "fixture",
+  }, () => handlers.startSession("alpha"));
+  assert.strictEqual(state.settings.backend, null, "project selection cannot silently replace a removed provider");
+  assert.match(sent.join("\n"), /\/backend/);
+}
+
+async function main() {
+  switchingAndProjectProbe();
+  newEndAndContinueProbe();
+  restartProbe();
+  commandRegistrationProbe();
+  await removedProviderSelectionProbe();
+  console.log("provider session commands OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => {
+  fs.rmSync(configDir, { recursive: true, force: true });
+});

package/test-provider-session-history.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const root = __dirname;
+const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-session-history-"));
+process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
+process.env.TELEGRAM_CHAT_ID = "fixture";
+process.env.OPEN_CLAUDIA_TEST = "1";
+
+const state = require("./core/state");
+const migration = require("./core/migration-backup");
+
+function migrationProbe() {
+  const legacy = {
+    alpha: [
+      { id: "legacy-a", title: "Legacy A", created: "2026-01-01T00:00:00.000Z", lastUsed: "2026-01-02T00:00:00.000Z" },
+    ],
+  };
+  const migrated = state.migrateSessionsDocument(legacy, {
+    defaultUserId: "telegram:fixture",
+    canonicalizeUserId: (value) => String(value),
+  });
+  assert.strictEqual(migrated.schemaVersion, state.SESSIONS_SCHEMA_VERSION);
+  const legacyRecord = migrated.users["telegram:fixture"].alpha[0];
+  assert.strictEqual(legacyRecord.provider, "legacy");
+  assert.strictEqual(legacyRecord.project, "alpha");
+  assert.strictEqual(legacyRecord.selectable, false);
+  assert.deepStrictEqual(
+    state.migrateSessionsDocument(migrated, {
+      defaultUserId: "telegram:fixture",
+      canonicalizeUserId: (value) => String(value),
+    }),
+    migrated,
+  );
+
+  const probed = state.migrateSessionsDocument(legacy, {
+    defaultUserId: "telegram:fixture",
+    canonicalizeUserId: (value) => String(value),
+    ownsSession(provider, context) {
+      return provider === "claude" && context.sessionId === "legacy-a";
+    },
+  });
+  assert.strictEqual(probed.users["telegram:fixture"].alpha[0].provider, "claude");
+  assert.strictEqual(probed.users["telegram:fixture"].alpha[0].selectable, true);
+
+  const ambiguous = state.migrateSessionsDocument(legacy, {
+    defaultUserId: "telegram:fixture",
+    canonicalizeUserId: (value) => String(value),
+    ownsSession: () => true,
+  });
+  assert.strictEqual(ambiguous.users["telegram:fixture"].alpha[0].provider, "legacy");
+  assert.strictEqual(ambiguous.users["telegram:fixture"].alpha[0].selectable, false);
+}
+
+function historyAndOwnershipProbe() {
+  const original = Buffer.from(JSON.stringify({
+    alpha: [{ id: "legacy-original", title: "Original" }],
+  }, null, 2));
+  fs.writeFileSync(path.join(configDir, "sessions.json"), original);
+  state.currentState();
+  state.saveState({ strict: true });
+
+  state.recordSession("owner@example.test", "alpha", "claude", "shared-id", "Claude Alpha", {
+    now: () => new Date("2026-02-01T00:00:00.000Z"),
+    strict: true,
+  });
+  state.recordSession("owner@example.test", "alpha", "codex", "shared-id", "Codex Alpha", {
+    now: () => new Date("2026-02-02T00:00:00.000Z"),
+    strict: true,
+  });
+  state.recordSession("owner@example.test", "beta", "claude", "shared-id", "Claude Beta", {
+    now: () => new Date("2026-02-03T00:00:00.000Z"),
+    strict: true,
+  });
+  state.recordSession("other@example.test", "alpha", "claude", "shared-id", "Other", {
+    now: () => new Date("2026-02-04T00:00:00.000Z"),
+    strict: true,
+  });
+
+  assert.strictEqual(state.userOwnsProviderSession("owner@example.test", "alpha", "claude", "shared-id"), true);
+  assert.strictEqual(state.userOwnsProviderSession("owner@example.test", "alpha", "codex", "shared-id"), true);
+  assert.strictEqual(state.userOwnsProviderSession("owner@example.test", "beta", "codex", "shared-id"), false);
+  assert.strictEqual(state.userOwnsProviderSession("intruder@example.test", "alpha", "claude", "shared-id"), false);
+
+  assert.deepStrictEqual(
+    state.getProjectSessions("owner@example.test", "alpha", "claude").map((entry) => entry.title),
+    ["Claude Alpha"],
+  );
+  assert.deepStrictEqual(
+    new Set(state.getProjectSessions("owner@example.test", "alpha").map((entry) => entry.provider)),
+    new Set(["claude", "codex"]),
+  );
+
+  state.recordSession("owner@example.test", "alpha", "claude", "older", "Older", {
+    now: () => new Date("2026-01-01T00:00:00.000Z"),
+    strict: true,
+  });
+  state.recordSession("owner@example.test", "alpha", "claude", "shared-id", null, {
+    now: () => new Date("2026-03-01T00:00:00.000Z"),
+    strict: true,
+  });
+  assert.strictEqual(state.getLastProjectSession("owner@example.test", "alpha", "claude").id, "shared-id");
+
+  const live = JSON.parse(fs.readFileSync(path.join(configDir, "sessions.json"), "utf8"));
+  assert.strictEqual(live.schemaVersion, state.SESSIONS_SCHEMA_VERSION);
+  assert.strictEqual(live.users["telegram:fixture"].alpha[0].provider, "legacy");
+  const journal = migration.readMigrationJournal(configDir);
+  assert.ok(journal.components.state);
+  assert.ok(journal.components.sessions);
+  const snapshotDir = path.join(migration.migrationRoot(configDir), ...journal.snapshot.split("/"));
+  assert.deepStrictEqual(fs.readFileSync(path.join(snapshotDir, "originals", "sessions.json")), original);
+}
+
+function callbackProbe() {
+  const { resolveSessionCallbackAction } = require("./core/actions");
+  const descriptor = {
+    userId: "owner@example.test",
+    project: "alpha",
+    provider: "claude",
+    sessionId: "shared-id",
+  };
+  const token = state.createSessionCallbackToken(descriptor, {
+    now: 1000,
+    ttlMs: 5000,
+    tokenFactory: () => "opaque-fixture-token",
+  });
+  assert.ok(`ss:${token}`.length <= 64);
+  assert.ok(!token.includes(descriptor.sessionId));
+  assert.strictEqual(state.consumeSessionCallbackToken(token, {
+    userId: descriptor.userId,
+    project: descriptor.project,
+    provider: descriptor.provider,
+    now: 2000,
+  }).status, "ok");
+  assert.strictEqual(state.consumeSessionCallbackToken(token, { ...descriptor, now: 2001 }).status, "expired");
+
+  const crossUser = state.createSessionCallbackToken(descriptor, {
+    now: 1000,
+    ttlMs: 5000,
+    tokenFactory: () => "cross-user-token",
+  });
+  assert.strictEqual(state.consumeSessionCallbackToken(crossUser, {
+    userId: "intruder@example.test",
+    project: "alpha",
+    provider: "claude",
+    now: 2000,
+  }).status, "forbidden");
+
+  const expired = state.createSessionCallbackToken(descriptor, {
+    now: 1000,
+    ttlMs: 5,
+    tokenFactory: () => "expired-token",
+  });
+  assert.strictEqual(state.consumeSessionCallbackToken(expired, { ...descriptor, now: 2000 }).status, "expired");
+
+  const liveState = {
+    userId: descriptor.userId,
+    currentSession: { name: descriptor.project, dir: "/workspace/alpha" },
+    settings: { backend: descriptor.provider },
+  };
+  const validAction = state.createSessionCallbackToken(descriptor, {
+    tokenFactory: () => "valid-action-token",
+  });
+  assert.strictEqual(resolveSessionCallbackAction(validAction, liveState).status, "ok");
+
+  const crossProviderAction = state.createSessionCallbackToken(descriptor, {
+    tokenFactory: () => "cross-provider-token",
+  });
+  assert.strictEqual(resolveSessionCallbackAction(crossProviderAction, {
+    ...liveState,
+    settings: { backend: "codex" },
+  }).status, "forbidden");
+
+  const staleAction = state.createSessionCallbackToken({ ...descriptor, sessionId: "not-owned" }, {
+    tokenFactory: () => "stale-action-token",
+  });
+  assert.strictEqual(resolveSessionCallbackAction(staleAction, liveState).status, "stale");
+  assert.strictEqual(resolveSessionCallbackAction("shared-id", liveState).status, "expired", "raw native IDs are not callbacks");
+}
+
+function integrationStaticProbe() {
+  const handlers = fs.readFileSync(path.join(root, "core", "handlers.js"), "utf8");
+  const actions = fs.readFileSync(path.join(root, "core", "actions.js"), "utf8");
+  assert.ok(!handlers.includes("callback_data: `ss:${s.id}`"));
+  assert.match(handlers, /createSessionCallbackToken/);
+  assert.match(handlers, /provider.*project|project.*provider/s);
+  assert.match(actions, /consumeSessionCallbackToken/);
+  assert.match(actions, /userOwnsProviderSession/);
+}
+
+try {
+  migrationProbe();
+  historyAndOwnershipProbe();
+  callbackProbe();
+  integrationStaticProbe();
+  console.log("provider session history OK");
+} finally {
+  fs.rmSync(configDir, { recursive: true, force: true });
+}