@harness-mix/cli 0.1.4 → 0.1.6

package/src/native-ui/renderer-extension/src/renderer-integrations-client.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+
+const serverSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  transportType: z.enum(['stdio', 'streamable_http']).optional(),
+  command: z.string().optional().default(''),
+  args: z.array(z.string()).optional().default([]),
+  env: z.record(z.string(), z.string()).optional(),
+  env_vars: z.array(z.string()).optional(),
+  cwd: z.string().nullable().optional(),
+  url: z.string().optional(),
+  bearer_token_env_var: z.string().optional(),
+  http_headers: z.record(z.string(), z.string()).optional(),
+  env_http_headers: z.record(z.string(), z.string()).optional(),
+  enabled: z.boolean(),
+  scope: z.enum(['global', 'project']),
+  editable: z.boolean(),
+  effective: z.boolean(),
+  appliedSessions: z.number(),
+});
+const skillSchema = z.object({ name: z.string(), path: z.string(), root: z.string(), enabled: z.boolean(), writable: z.boolean(), scope: z.enum(['global', 'project']), status: z.string() });
+const snapshotSchema = z.object({ harnessId: z.string(), mcpSupported: z.boolean(), skillsSupported: z.boolean(), servers: z.array(serverSchema), native: z.array(z.object({ sessionId: z.string(), name: z.string(), status: z.string(), tools: z.array(z.string()) })), skills: z.array(skillSchema), note: z.string() });
+const catalogSchema = z.object({ harnesses: z.array(z.object({ id: z.string(), name: z.string(), available: z.boolean(), mcp: z.boolean(), skills: z.boolean() })) });
+export type IntegrationSnapshot = z.infer<typeof snapshotSchema>;
+export interface IntegrationScope { harnessId: string; scope: 'global' | 'project'; cwd?: string }
+export interface ManagedServer {
+  id?: string | undefined;
+  name: string;
+  transportType?: 'stdio' | 'streamable_http' | undefined;
+  command?: string | undefined;
+  args?: string[] | undefined;
+  env?: Record<string, string> | undefined;
+  env_vars?: string[] | undefined;
+  cwd?: string | null | undefined;
+  url?: string | undefined;
+  bearer_token_env_var?: string | undefined;
+  http_headers?: Record<string, string> | undefined;
+  env_http_headers?: Record<string, string> | undefined;
+  enabled: boolean;
+}
+export interface DroppedSkillFile { path: string; contentBase64: string }
+export interface SkillChange { name: string; root?: string; source?: string; files?: DroppedSkillFile[]; action: 'install' | 'enable' | 'disable' }
+export interface RendererIntegrationsClient {
+  integrationCatalog(): Promise<z.infer<typeof catalogSchema>>;
+  listIntegrations(input: IntegrationScope): Promise<IntegrationSnapshot>;
+  saveMcp(input: IntegrationScope & { server: ManagedServer }): Promise<unknown>;
+  removeMcp(input: IntegrationScope & { id: string }): Promise<unknown>;
+  changeSkill(input: IntegrationScope & SkillChange): Promise<unknown>;
+}
+export function createRendererIntegrationsClient(send: (method: string, params: unknown) => Promise<unknown>): RendererIntegrationsClient {
+  return {
+    integrationCatalog: async () => catalogSchema.parse(await send('codexhost/integrations/catalog', {})),
+    listIntegrations: async input => snapshotSchema.parse(await send('codexhost/integrations/list', input)),
+    saveMcp: input => send('codexhost/integrations/mcp/save', input),
+    removeMcp: input => send('codexhost/integrations/mcp/remove', input),
+    changeSkill: input => send('codexhost/integrations/skill/change', input),
+  };
+}

package/src/native-ui/renderer-extension/src/renderer-model-client.ts

@@ -1,3 +1,4 @@
+import { createRendererIntegrationsClient, type RendererIntegrationsClient } from './renderer-integrations-client.js';
 import {
   harnessAccountListResultSchema,
   type HarnessAccountListResult,
@@ -127,6 +128,7 @@ export const THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
 export const UPDATE_CHECK_METHOD = "codexhost/update/check";
 export const UPDATE_START_METHOD = "codexhost/update/start";
 export const UPDATE_STATUS_METHOD = "codexhost/update/status";
+export const RUNTIME_VERSION_METHOD = "harness-mix/runtime/version";
 export const CODEX_ACCOUNT_LIST_METHOD = "codexhost/account/list";
 export const CODEX_ACCOUNT_REFRESH_METHOD = "codexhost/account/refresh";
 export const CODEX_ACCOUNT_CREATE_METHOD = "codexhost/account/create";
@@ -171,7 +173,7 @@ function notificationTarget(manager: RequestManagerCandidate): RequestManagerCan
   return nested && typeof nested.addNotificationCallback === "function" ? nested : null;
 }
 
-export interface RendererModelClient extends Partial<RendererSessionImportClient> {
+export interface RendererModelClient extends Partial<RendererSessionImportClient>, Partial<RendererIntegrationsClient> {
   listCollaborationAgents?(): Promise<Array<{ id: string; name: string; available: boolean; lead: boolean }>>;
   currentHostId?(): string | null;
   listHarnessPlugins?(): Promise<HarnessPluginListResult>;
@@ -197,6 +199,7 @@ export interface RendererModelClient extends Partial<RendererSessionImportClient
   checkUpdate(): Promise<UpdateCheckResult>;
   startUpdate(): Promise<UpdateStartResult>;
   readUpdateStatus(): Promise<UpdateStatusResult>;
+  readCurrentVersion?(): Promise<{ version: string }>;
   inspectCodexAccountUsage?(input: CodexAccountUsageParams): Promise<CodexAccountUsageResult>;
   consumeCodexAccountResetCredit?(
     input: CodexAccountResetCreditConsumeParams,
@@ -213,6 +216,7 @@ export interface RendererModelClient extends Partial<RendererSessionImportClient
   cancelCodexAccountLogin(
     input: CodexAccountLoginCancelParams,
   ): Promise<CodexAccountLoginCancelResult>;
+  logoutCodexAccount?(): Promise<CodexAccountMutationResult>;
   subscribeCodexAccountLogin(listener: (result: CodexAccountLoginCompleted) => void): () => void;
 }
 
@@ -331,6 +335,7 @@ export function createRendererModelClient(
       if (!Array.isArray(result) || !result.every(a => a && typeof a.id === 'string' && typeof a.name === 'string' && typeof a.available === 'boolean' && typeof a.lead === 'boolean')) throw new Error('Invalid collaboration catalog');
       return result;
     },
+    ...createRendererIntegrationsClient((method, params) => manager.sendRequest(method, params)),
     ...createRendererSessionImportClient(async (method, params) =>
       manager.sendRequest(method, params),
     ),
@@ -477,6 +482,13 @@ export function createRendererModelClient(
       );
       return updateStatusResultSchema.parse(result);
     },
+    async readCurrentVersion(): Promise<{ version: string }> {
+      const result = await manager.sendRequest(RUNTIME_VERSION_METHOD, {});
+      if (!isRecord(result) || typeof result.version !== "string" || !result.version.trim()) {
+        throw new Error("Invalid Harness Mix version response");
+      }
+      return { version: result.version.trim() };
+    },
     async inspectCodexAccountUsage(
       input: CodexAccountUsageParams,
     ): Promise<CodexAccountUsageResult> {
@@ -549,6 +561,10 @@ export function createRendererModelClient(
       );
       return codexAccountLoginCancelResultSchema.parse(result);
     },
+    async logoutCodexAccount(): Promise<CodexAccountMutationResult> {
+      const result = await manager.sendRequest("codexhost/account/logout", {});
+      return codexAccountMutationResultSchema.parse(result);
+    },
     subscribeCodexAccountLogin(listener: (result: CodexAccountLoginCompleted) => void): () => void {
       const notifications = notificationTarget(source);
       if (!notifications?.addNotificationCallback) {

package/src/native-ui/renderer-extension/src/renderer-settings-lifecycle.ts

@@ -24,6 +24,7 @@ const UPDATE_CHECK_TIMEOUT_MS = 5_000;
 const UPDATE_RETRY_DELAYS_MS = [1_000, 3_000, 10_000, 30_000] as const;
 
 export interface RendererSettingsLifecycleOptions {
+  getIntegrationsClient?(): import('./renderer-integrations-client.js').RendererIntegrationsClient | null;
   getUpdateClient?(): RendererUpdateClient | null;
   getConnectionDiagnostics?(): RendererConnectionDiagnostics | null;
   getAccountClient?(): RendererCodexAccountClient | null;
@@ -74,6 +75,7 @@ export function installRendererSettingsLifecycle(
         await options.openImportedThread(threadId, signal);
         if (!disposed && !signal.aborted) shell?.close();
       },
+      options.getIntegrationsClient,
     );
     const nextShell = installRendererSettingsShell(definitions, messages, ownerWindow.document);
     const nextTrigger = installRendererSettingsHeaderTrigger({

package/src/native-ui/renderer-extension/src/settings/accounts-list.ts

@@ -12,6 +12,10 @@ import type { RendererSettingsMessages } from "./localization.js";
 
 let resetDetailsSequence = 0;
 
+export function isCodexAccountAuthenticated(account: CodexAccountSummary): boolean {
+  return account.authenticated ?? Boolean(account.email);
+}
+
 function accountPlanLabel(planType: CodexAccountSummary["planType"]): string | null {
   if (!planType || planType === "unknown") return null;
   if (planType === "free") return "Free";
@@ -90,6 +94,7 @@ export function renderAccountRows(
     resetExpanded: boolean;
     onActivate: () => void;
     onSignIn: () => void;
+    onSignOut?: () => void;
     onDelete: () => void;
     onRetry: () => void;
     onUseReset?: () => void;
@@ -176,7 +181,7 @@ export function renderAccountRows(
     activate.addEventListener("click", input.onActivate);
     actions.append(activate);
   }
-  if (!account.email) {
+  if (!isCodexAccountAuthenticated(account)) {
     const signIn = document.createElement("button");
     signIn.type = "button";
     signIn.className = "settings-account-action";
@@ -186,6 +191,16 @@ export function renderAccountRows(
     signIn.addEventListener("click", input.onSignIn);
     actions.append(signIn);
   }
+  if (account.management === "native" && isCodexAccountAuthenticated(account) && input.onSignOut) {
+    const signOut = document.createElement("button");
+    signOut.type = "button";
+    signOut.className = "settings-account-action";
+    signOut.textContent = messages.accountSignOut;
+    signOut.dataset.accountFocus = `${account.accountId}:logout`;
+    signOut.disabled = input.actionsDisabled;
+    signOut.addEventListener("click", input.onSignOut);
+    actions.append(signOut);
+  }
   // isDefault protects the native Account home; active selects the Account for
   // new tasks. Preserve these distinct Host semantics when exposing deletion.
   if (!account.isDefault) {

package/src/native-ui/renderer-extension/src/settings/accounts-page.ts

@@ -20,6 +20,7 @@ import type {
 import {
   accountListFocusRestorer,
   createAccountsTable,
+  isCodexAccountAuthenticated,
   renderAccountRows,
 } from "./accounts-list.js";
 import { mountHarnessAccounts, type RendererHarnessAccountClient } from "./harness-accounts.js";
@@ -44,6 +45,7 @@ export interface RendererCodexAccountClient extends RendererHarnessAccountClient
   cancelCodexAccountLogin(
     input: CodexAccountLoginCancelParams,
   ): Promise<CodexAccountLoginCancelResult>;
+  logoutCodexAccount?(): Promise<CodexAccountMutationResult>;
   subscribeCodexAccountLogin?(listener: (result: CodexAccountLoginCompleted) => void): () => void;
 }
 
@@ -224,13 +226,13 @@ export function createAccountsSettingsPage(
         const restoreFocus = accountListFocusRestorer(list, search);
         body.replaceChildren();
         status.textContent = loginMessage ?? "";
-        connectedCount.textContent = String(accounts.filter((account) => account.email).length);
+        connectedCount.textContent = String(accounts.filter(isCodexAccountAuthenticated).length);
         search.disabled = login !== null || loginStartingAccountId !== null;
         for (const [display, button] of displayButtons) {
           button.setAttribute("aria-pressed", String(display === usageDisplay));
         }
         refreshUsage.disabled =
-          ((!getClient()?.inspectCodexAccountUsage || !accounts.some((account) => account.email)) &&
+          ((!getClient()?.inspectCodexAccountUsage || !accounts.some(isCodexAccountAuthenticated)) &&
             !getClient()?.listHarnessAccounts) ||
           harnessAccounts?.refreshing === true ||
           [...usageByAccountId.values()].some((usage) => usage.status === "loading") ||
@@ -249,6 +251,9 @@ export function createAccountsSettingsPage(
           emptyRow.append(emptyCell);
           body.append(emptyRow);
         }
+        // The stock Codex account remains protected, while additional Accounts
+        // are native Codex profiles isolated by CODEX_HOME.
+        add.hidden = false;
         add.disabled = accountBusy();
         for (const account of visibleAccounts) {
           body.append(
@@ -262,6 +267,9 @@ export function createAccountsSettingsPage(
               onActivate: () =>
                 mutate(() => client().activateCodexAccount({ accountId: account.accountId })),
               onSignIn: () => startLogin(account.accountId),
+              ...(account.management === "native" && getClient()?.logoutCodexAccount
+                ? { onSignOut: () => signOut() }
+                : {}),
               onDelete: () => deleteAccount(account.accountId),
               onRetry: () => {
                 usageByAccountId.delete(account.accountId);
@@ -341,7 +349,7 @@ export function createAccountsSettingsPage(
       };
       const loadUsage = (nextAccounts: readonly CodexAccountSummary[]): void => {
         const inspect = getClient()?.inspectCodexAccountUsage;
-        const signedIn = nextAccounts.filter((account) => account.email);
+        const signedIn = nextAccounts.filter(isCodexAccountAuthenticated);
         const keep = new Set(signedIn.map((account) => account.accountId));
         for (const accountId of [...usageByAccountId.keys()]) {
           if (!keep.has(accountId)) usageByAccountId.delete(accountId);
@@ -455,6 +463,27 @@ export function createAccountsSettingsPage(
           },
         });
       };
+      const signOut = (): void => {
+        const logout = getClient()?.logoutCodexAccount;
+        if (!logout || accountBusy()) return;
+        if (document.defaultView?.confirm?.(messages.accountSignOutConfirm) === false) return;
+        accountActivating = true;
+        loginMessage = messages.accountSigningOut;
+        render();
+        void context.runLatest(() => logout(), {
+          success(result) {
+            accountActivating = false;
+            loginMessage = messages.accountSignedOut;
+            usageByAccountId.clear();
+            setAccounts([result.account]);
+          },
+          failure(error) {
+            accountActivating = false;
+            loginMessage = errorMessage(error, messages.accountSignOutFailed);
+            render();
+          },
+        });
+      };
       const createAndLogin = (): void => {
         if (accountBusy()) return;
         accountCreating = true;