@gakr-gakr/codex 0.1.0 → 0.1.1

package/src/command-plugins-management.ts

@@ -1,137 +0,0 @@
-import type { PluginCommandContext, PluginCommandResult } from "autobot/plugin-sdk/plugin-entry";
-import { formatCodexDisplayText } from "./command-formatters.js";
-
-/**
- * Lightweight read/write surface over the Autobot config file. Plugged in by
- * the command registration site so this module stays decoupled from the
- * concrete `mutateConfigFile` import in tests.
- */
-export type CodexPluginsManagementIO = {
-  readConfig: () => Promise<{
-    enabled?: boolean;
-    plugins?: Record<string, CodexPluginConfigEntry>;
-  }>;
-  mutate: (update: (block: CodexPluginsConfigBlock) => void) => Promise<void>;
-};
-
-export type CodexPluginConfigEntry = {
-  enabled?: boolean;
-  marketplaceName?: string;
-  pluginName?: string;
-  allow_destructive_actions?: boolean;
-};
-
-export type CodexPluginsConfigBlock = {
-  enabled?: boolean;
-  plugins?: Record<string, CodexPluginConfigEntry>;
-};
-
-// Plugin lifecycle changes (enable/disable) write to autobot.json
-// synchronously. The Codex app-server picks up the new policy when the next
-// thread starts; in-flight conversations keep the old policy until /new or
-// /reset. A full gateway restart is NOT needed.
-const POLICY_REFRESH_HINT =
-  "New Codex conversations pick this up automatically. Use /new or /reset to refresh the current one.";
-
-export async function handleCodexPluginsSubcommand(
-  ctx: PluginCommandContext,
-  rest: string[],
-  io: CodexPluginsManagementIO,
-): Promise<PluginCommandResult> {
-  const [verb = "list", ...args] = rest;
-  const normalized = verb.toLowerCase();
-
-  if (normalized === "list") {
-    if (args.length > 0) {
-      return { text: "Usage: /codex plugins list" };
-    }
-    const current = await io.readConfig();
-    return {
-      text: formatPluginList(current.plugins ?? {}, { globalEnabled: current.enabled === true }),
-    };
-  }
-
-  const target = args[0];
-  if (normalized === "enable" || normalized === "disable") {
-    if (!target || args.length > 1) {
-      return { text: `Usage: /codex plugins ${normalized} <name>` };
-    }
-    if (!canMutateCodexPlugins(ctx)) {
-      return {
-        text: `Only an owner or operator.admin gateway client can run /codex plugins ${normalized}.`,
-      };
-    }
-    const wantEnabled = normalized === "enable";
-    const current = (await io.readConfig()).plugins ?? {};
-    if (!current[target]) {
-      return {
-        text: `Codex sub-plugin '${formatCodexDisplayText(target)}' is not configured. Run '/codex plugins list' to see configured plugins.`,
-      };
-    }
-    await io.mutate((block) => {
-      if (wantEnabled) {
-        block.enabled = true;
-      }
-      block.plugins ??= {};
-      block.plugins[target] = { ...block.plugins[target], enabled: wantEnabled };
-    });
-    return {
-      text: `${formatCodexDisplayText(target)}: ${wantEnabled ? "enabled" : "disabled"} in autobot.json. ${POLICY_REFRESH_HINT}`,
-    };
-  }
-
-  return {
-    text: `Unknown /codex plugins subcommand: ${formatCodexDisplayText(verb)}\n\n${buildPluginsHelp()}`,
-  };
-}
-
-function canMutateCodexPlugins(ctx: PluginCommandContext): boolean {
-  if (ctx.senderIsOwner === true) {
-    return true;
-  }
-  return ctx.gatewayClientScopes?.includes("operator.admin") === true;
-}
-
-export function buildPluginsHelp(): string {
-  return [
-    "Codex sub-plugin management (writes only to ~/.autobot/autobot.json, never to ~/.codex/config.toml):",
-    "- /codex plugins                  (alias for list)",
-    "- /codex plugins list             show all configured Codex sub-plugins",
-    "- /codex plugins enable <name>    enable a configured sub-plugin",
-    "- /codex plugins disable <name>   disable a configured sub-plugin",
-  ].join("\n");
-}
-
-export function formatPluginList(
-  plugins: Record<string, CodexPluginConfigEntry>,
-  options: { globalEnabled?: boolean } = {},
-): string {
-  const globalEnabled = options.globalEnabled === true;
-  const keys = Object.keys(plugins).toSorted();
-  if (keys.length === 0) {
-    return "No Codex sub-plugins configured under plugins.entries.codex.config.codexPlugins.plugins";
-  }
-  const rows = keys.map((key) => {
-    const entry = plugins[key] ?? {};
-    const state = globalEnabled && entry.enabled !== false ? "ON " : "OFF";
-    const displayKey = formatCodexDisplayText(key);
-    const pluginName = formatCodexDisplayText(entry.pluginName ?? key);
-    const marketplace = formatCodexDisplayText(entry.marketplaceName ?? "?");
-    return { displayKey, state, pluginName, marketplace };
-  });
-  const keyW = Math.max(...rows.map((r) => r.displayKey.length));
-  const pluginW = Math.max(...rows.map((r) => r.pluginName.length));
-  return [
-    "Codex sub-plugins in Autobot config (~/.autobot/autobot.json):",
-    "",
-    ...rows.map(
-      (r) =>
-        `  ${r.state}  ${r.displayKey.padEnd(keyW)}  ${r.pluginName.padEnd(pluginW)}  [${r.marketplace}]`,
-    ),
-    "",
-    ...(globalEnabled
-      ? []
-      : ["Global codexPlugins.enabled is off; configured sub-plugins are inactive.", ""]),
-    "New Codex conversations pick up policy changes automatically; /new or /reset to refresh the current one.",
-  ].join("\n");
-}

package/src/command-rpc.ts

@@ -1,142 +0,0 @@
-import type { resolveCodexAppServerAuthProfileIdForAgent } from "./app-server/auth-bridge.js";
-import {
-  CODEX_CONTROL_METHODS,
-  describeControlFailure,
-  type CodexControlMethod,
-} from "./app-server/capabilities.js";
-import { resolveCodexAppServerRuntimeOptions } from "./app-server/config.js";
-import { listCodexAppServerModels } from "./app-server/models.js";
-import type {
-  CodexAppServerRequestMethod,
-  CodexAppServerRequestParams,
-  CodexAppServerRequestResult,
-  JsonValue,
-} from "./app-server/protocol.js";
-import { requestCodexAppServerJson } from "./app-server/request.js";
-
-export type SafeValue<T> = { ok: true; value: T } | { ok: false; error: string };
-
-type AuthProfileOrderConfig = Parameters<
-  typeof resolveCodexAppServerAuthProfileIdForAgent
->[0]["config"];
-
-export type CodexControlRequestOptions = {
-  config?: AuthProfileOrderConfig;
-  authProfileId?: string;
-  agentDir?: string;
-  isolated?: boolean;
-};
-
-export function requestOptions(
-  pluginConfig: unknown,
-  limit: number,
-  config?: AuthProfileOrderConfig,
-) {
-  const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-  return {
-    limit,
-    timeoutMs: runtime.requestTimeoutMs,
-    startOptions: runtime.start,
-    config,
-  };
-}
-
-type CodexControlRequestMethod = CodexControlMethod & CodexAppServerRequestMethod;
-
-export function codexControlRequest<M extends CodexControlRequestMethod>(
-  pluginConfig: unknown,
-  method: M,
-  requestParams: CodexAppServerRequestParams<M>,
-  options?: CodexControlRequestOptions,
-): Promise<CodexAppServerRequestResult<M>>;
-export function codexControlRequest(
-  pluginConfig: unknown,
-  method: CodexControlMethod,
-  requestParams?: JsonValue,
-  options?: CodexControlRequestOptions,
-): Promise<JsonValue | undefined>;
-export async function codexControlRequest(
-  pluginConfig: unknown,
-  method: CodexControlMethod,
-  requestParams?: unknown,
-  options: CodexControlRequestOptions = {},
-) {
-  const runtime = resolveCodexAppServerRuntimeOptions({ pluginConfig });
-  return await requestCodexAppServerJson({
-    method,
-    requestParams,
-    timeoutMs: runtime.requestTimeoutMs,
-    startOptions: runtime.start,
-    config: options.config,
-    authProfileId: options.authProfileId,
-    agentDir: options.agentDir,
-    isolated: options.isolated,
-  });
-}
-
-export function safeCodexControlRequest<M extends CodexControlRequestMethod>(
-  pluginConfig: unknown,
-  method: M,
-  requestParams: CodexAppServerRequestParams<M>,
-  options?: CodexControlRequestOptions,
-): Promise<SafeValue<CodexAppServerRequestResult<M>>>;
-export function safeCodexControlRequest(
-  pluginConfig: unknown,
-  method: CodexControlMethod,
-  requestParams?: JsonValue,
-  options?: CodexControlRequestOptions,
-): Promise<SafeValue<JsonValue | undefined>>;
-export async function safeCodexControlRequest(
-  pluginConfig: unknown,
-  method: CodexControlMethod,
-  requestParams?: unknown,
-  options: CodexControlRequestOptions = {},
-) {
-  return await safeValue(
-    async () =>
-      await codexControlRequest(pluginConfig, method, requestParams as JsonValue, options),
-  );
-}
-
-async function safeCodexModelList(
-  pluginConfig: unknown,
-  limit: number,
-  config?: AuthProfileOrderConfig,
-) {
-  return await safeValue(
-    async () => await listCodexAppServerModels(requestOptions(pluginConfig, limit, config)),
-  );
-}
-
-export async function readCodexStatusProbes(
-  pluginConfig: unknown,
-  config?: AuthProfileOrderConfig,
-) {
-  const [models, account, limits, mcps, skills] = await Promise.all([
-    safeCodexModelList(pluginConfig, 20, config),
-    safeCodexControlRequest(
-      pluginConfig,
-      CODEX_CONTROL_METHODS.account,
-      { refreshToken: false },
-      { config },
-    ),
-    safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.rateLimits, undefined, { config }),
-    safeCodexControlRequest(
-      pluginConfig,
-      CODEX_CONTROL_METHODS.listMcpServers,
-      { limit: 100 },
-      { config },
-    ),
-    safeCodexControlRequest(pluginConfig, CODEX_CONTROL_METHODS.listSkills, {}, { config }),
-  ]);
-
-  return { models, account, limits, mcps, skills };
-}
-
-export async function safeValue<T>(read: () => Promise<T>): Promise<SafeValue<T>> {
-  try {
-    return { ok: true, value: await read() };
-  } catch (error) {
-    return { ok: false, error: describeControlFailure(error) };
-  }
-}

package/src/commands.ts

@@ -1,65 +0,0 @@
-import type {
-  AutoBotPluginCommandDefinition,
-  PluginCommandContext,
-  PluginCommandResult,
-} from "autobot/plugin-sdk/plugin-entry";
-import { describeControlFailure } from "./app-server/capabilities.js";
-import { formatCodexDisplayText } from "./command-formatters.js";
-import type { CodexCommandDeps } from "./command-handlers.js";
-
-type CodexCommandOptions = {
-  pluginConfig?: unknown;
-  deps?: Partial<CodexCommandDeps>;
-};
-
-type CodexSubcommandHandler = (
-  ctx: PluginCommandContext,
-  options: CodexCommandOptions,
-) => Promise<PluginCommandResult>;
-
-type CodexCommandInternalOptions = CodexCommandOptions & {
-  loadSubcommandHandler?: () => Promise<CodexSubcommandHandler>;
-};
-
-export function createCodexCommand(options: CodexCommandOptions): AutoBotPluginCommandDefinition {
-  return {
-    name: "codex",
-    description: "Inspect and control the Codex app-server harness",
-    ownership: "reserved",
-    agentPromptGuidance: [
-      {
-        text: "Native Codex app-server plugin is available (`/codex ...`). For Codex bind/control/thread/resume/steer/stop requests, prefer `/codex bind`, `/codex threads`, `/codex resume`, `/codex steer`, and `/codex stop` over ACP.",
-        surfaces: ["pi_main"],
-      },
-      {
-        text: "Use ACP for Codex only when the user explicitly asks for ACP/acpx or wants to test the ACP path.",
-        surfaces: ["pi_main"],
-      },
-    ],
-    acceptsArgs: true,
-    requireAuth: true,
-    handler: (ctx) => handleCodexCommand(ctx, options),
-  };
-}
-
-export async function handleCodexCommand(
-  ctx: PluginCommandContext,
-  options: CodexCommandInternalOptions = {},
-): Promise<PluginCommandResult> {
-  const { loadSubcommandHandler, ...subcommandOptions } = options;
-  try {
-    const handleCodexSubcommand = loadSubcommandHandler
-      ? await loadSubcommandHandler()
-      : await loadDefaultCodexSubcommandHandler();
-    return await handleCodexSubcommand(ctx, subcommandOptions);
-  } catch (error) {
-    return {
-      text: `Codex command failed: ${formatCodexDisplayText(describeControlFailure(error))}`,
-    };
-  }
-}
-
-async function loadDefaultCodexSubcommandHandler(): Promise<CodexSubcommandHandler> {
-  const { handleCodexSubcommand } = await import("./command-handlers.js");
-  return handleCodexSubcommand;
-}

package/src/conversation-binding-data.ts

@@ -1,124 +0,0 @@
-import process from "node:process";
-import type { PluginConversationBinding } from "autobot/plugin-sdk/plugin-entry";
-
-const BINDING_DATA_VERSION = 1;
-
-export type CodexAppServerConversationBindingData = {
-  kind: "codex-app-server-session";
-  version: 1;
-  sessionFile: string;
-  workspaceDir: string;
-  agentDir?: string;
-};
-
-export type CodexCliNodeConversationBindingData = {
-  kind: "codex-cli-node-session";
-  version: 1;
-  nodeId: string;
-  sessionId: string;
-  cwd?: string;
-};
-
-export type CodexConversationBindingData =
-  | CodexAppServerConversationBindingData
-  | CodexCliNodeConversationBindingData;
-
-export function createCodexConversationBindingData(params: {
-  sessionFile: string;
-  workspaceDir: string;
-  agentDir?: string;
-}): CodexAppServerConversationBindingData {
-  const agentDir = params.agentDir?.trim();
-  return {
-    kind: "codex-app-server-session",
-    version: BINDING_DATA_VERSION,
-    sessionFile: params.sessionFile,
-    workspaceDir: params.workspaceDir,
-    ...(agentDir ? { agentDir } : {}),
-  };
-}
-
-export function createCodexCliNodeConversationBindingData(params: {
-  nodeId: string;
-  sessionId: string;
-  cwd?: string;
-}): CodexCliNodeConversationBindingData {
-  const cwd = params.cwd?.trim();
-  return {
-    kind: "codex-cli-node-session",
-    version: BINDING_DATA_VERSION,
-    nodeId: params.nodeId,
-    sessionId: params.sessionId,
-    ...(cwd ? { cwd } : {}),
-  };
-}
-
-export function readCodexConversationBindingData(
-  binding: PluginConversationBinding | null | undefined,
-): CodexConversationBindingData | undefined {
-  const data = binding?.data;
-  if (!data || typeof data !== "object" || Array.isArray(data)) {
-    return undefined;
-  }
-  return readCodexConversationBindingDataRecord(data);
-}
-
-export function readCodexConversationBindingDataRecord(
-  data: Record<string, unknown>,
-): CodexConversationBindingData | undefined {
-  if (data.kind === "codex-cli-node-session") {
-    if (
-      data.version !== BINDING_DATA_VERSION ||
-      typeof data.nodeId !== "string" ||
-      !data.nodeId.trim() ||
-      typeof data.sessionId !== "string" ||
-      !data.sessionId.trim()
-    ) {
-      return undefined;
-    }
-    return {
-      kind: "codex-cli-node-session",
-      version: BINDING_DATA_VERSION,
-      nodeId: data.nodeId.trim(),
-      sessionId: data.sessionId.trim(),
-      cwd: typeof data.cwd === "string" && data.cwd.trim() ? data.cwd.trim() : undefined,
-    };
-  }
-  if (data.kind !== "codex-app-server-session") {
-    return undefined;
-  }
-  if (
-    data.version !== BINDING_DATA_VERSION ||
-    typeof data.sessionFile !== "string" ||
-    !data.sessionFile.trim()
-  ) {
-    return undefined;
-  }
-  return {
-    kind: "codex-app-server-session",
-    version: BINDING_DATA_VERSION,
-    sessionFile: data.sessionFile,
-    workspaceDir:
-      typeof data.workspaceDir === "string" && data.workspaceDir.trim()
-        ? data.workspaceDir
-        : process.cwd(),
-    agentDir: typeof data.agentDir === "string" && data.agentDir.trim() ? data.agentDir : undefined,
-  };
-}
-
-export function resolveCodexDefaultWorkspaceDir(pluginConfig: unknown): string {
-  const appServer = readRecord(readRecord(pluginConfig)?.appServer);
-  const configured = readString(appServer, "defaultWorkspaceDir");
-  return configured ?? process.cwd();
-}
-
-function readRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : undefined;
-}
-
-function readString(record: Record<string, unknown> | undefined, key: string) {
-  const value = record?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}