@otto-code/protocol 0.8.9 → 0.8.12

package/dist/git-operations.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+/**
+ * Otto git-operation wire schemas: the checkout.git.* commit, rollback, operation-log, blame and file-history RPCs and pushes. Fork-only capability, so it owns its schemas; messages.ts re-exports them. The checkout.git.file_* and fetch RPCs stay in messages.ts because they embed Paseo's ParsedDiffFileSchema and CheckoutErrorSchema.
+ */
+// One entry in a git operation log (the "Git Commit"/"Git Push" log panes).
+// `seq` is a per-(cwd, operation) monotonic counter used for client-side
+// dedup between backfill and live pushes.
+export const GitOperationLogEntrySchema = z.object({
+    seq: z.number(),
+    timestamp: z.string(),
+    level: z.enum(["info", "output", "error"]),
+    text: z.string(),
+});
+// Backfill for a git operation log pane. `operation` is an open string on the
+// wire ("commit" | "pull" | "push" today) so newly watchable operations don't
+// break old peers. Gated by server_info.features.checkoutGitLog.
+export const CheckoutGitGetOperationLogRequestSchema = z.object({
+    type: z.literal("checkout.git.get_operation_log.request"),
+    cwd: z.string(),
+    operation: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutGitGetOperationLogResponseSchema = z.object({
+    type: z.literal("checkout.git.get_operation_log.response"),
+    payload: z.object({
+        cwd: z.string(),
+        operation: z.string(),
+        entries: z.array(GitOperationLogEntrySchema),
+        requestId: z.string(),
+    }),
+});
+// Live append notification, broadcast to connected clients while a watched git
+// operation runs. Carries only the appended entries; `seq` orders them against
+// the backfill.
+export const CheckoutGitLogAppendedNotificationSchema = z.object({
+    type: z.literal("checkout.git.log_appended.notification"),
+    payload: z.object({
+        cwd: z.string(),
+        operation: z.string(),
+        entries: z.array(GitOperationLogEntrySchema),
+    }),
+});
+// Namespaced successor to checkout_commit_request: per-file selection and
+// structured errors. Gated by server_info.features.checkoutGitCommit; the flat
+// RPC stays accepted for old clients.
+export const CheckoutGitCommitRequestSchema = z.object({
+    type: z.literal("checkout.git.commit.request"),
+    cwd: z.string(),
+    message: z.string(),
+    // Repo-relative paths to stage and commit. Only these paths land in the
+    // commit, even if other changes are already staged.
+    paths: z.array(z.string()),
+    // Set after the user confirms committing while agents are running in this
+    // workspace; without it the daemon refuses with kind "agents_running".
+    allowWithRunningAgents: z.boolean().optional(),
+    requestId: z.string(),
+});
+// Resolve which agent the daemon would use to author a commit message for this
+// checkout (the "writer" role) so the client can name it in a confirmation
+// before running the AI-authored commit. A pure query - it never commits. Gated
+// by server_info.features.checkoutGitCommitAgent.
+export const CheckoutGitCommitAgentRequestSchema = z.object({
+    type: z.literal("checkout.git.commit_agent.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+// Discard uncommitted working-tree changes for specific repo-relative paths
+// (restore tracked files from HEAD, delete newly-added files). Gated by
+// server_info.features.checkoutGitRollback.
+export const CheckoutGitRollbackRequestSchema = z.object({
+    type: z.literal("checkout.git.rollback.request"),
+    cwd: z.string(),
+    // Repo-relative paths whose uncommitted changes should be discarded.
+    paths: z.array(z.string()),
+    // Set after the user confirms rolling back while agents are running in this
+    // workspace; without it the daemon refuses with kind "agents_running", since
+    // discarding a live agent's uncommitted edits mid-run can destroy its work.
+    allowWithRunningAgents: z.boolean().optional(),
+    requestId: z.string(),
+});
+export const CheckoutGitCommitRunningAgentSchema = z.object({
+    id: z.string(),
+    title: z.string().nullable(),
+});
+export const CheckoutGitCommitErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("agents_running"),
+        agents: z.array(CheckoutGitCommitRunningAgentSchema),
+    }),
+    z.object({
+        kind: z.literal("identity_missing"),
+        missingName: z.boolean(),
+        missingEmail: z.boolean(),
+    }),
+    z.object({
+        kind: z.literal("hook_failed"),
+        output: z.string(),
+        exitCode: z.number().nullable(),
+    }),
+    z.object({
+        kind: z.literal("signing_failed"),
+        detail: z.string(),
+    }),
+    z.object({
+        kind: z.literal("nothing_to_commit"),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const CheckoutGitCommitResponseSchema = z.object({
+    type: z.literal("checkout.git.commit.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        commitSha: z.string().nullable(),
+        error: CheckoutGitCommitErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+// The agent the daemon resolved to author a commit message. "personality" when
+// an available role-matched Agent Personality wins the mini-task routing (its
+// name plus the bound provider/model); "provider" when a bare provider/model is
+// used instead; "none" when nothing is configured to run the task, in which case
+// the client refuses the AI commit rather than falling back to placeholder text.
+export const CommitMessageAgentSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("personality"),
+        personalityId: z.string(),
+        personalityName: z.string(),
+        provider: z.string(),
+        providerLabel: z.string(),
+        model: z.string().nullable(),
+        modelLabel: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("provider"),
+        provider: z.string(),
+        providerLabel: z.string(),
+        model: z.string().nullable(),
+        modelLabel: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("none"),
+    }),
+]);
+export const CheckoutGitCommitAgentResponseSchema = z.object({
+    type: z.literal("checkout.git.commit_agent.response"),
+    payload: z.object({
+        cwd: z.string(),
+        agent: CommitMessageAgentSchema,
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitRollbackErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("nothing_to_rollback"),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+    // Refused because agents are running in this workspace; discarding their
+    // uncommitted edits mid-run risks destroying work. The client re-sends with
+    // allowWithRunningAgents after confirming, mirroring the commit flow.
+    z.object({
+        kind: z.literal("agents_running"),
+        agents: z.array(CheckoutGitCommitRunningAgentSchema),
+    }),
+]);
+export const CheckoutGitRollbackResponseSchema = z.object({
+    type: z.literal("checkout.git.rollback.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        // Repo-relative paths whose changes were discarded.
+        rolledBackPaths: z.array(z.string()),
+        error: CheckoutGitRollbackErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const GitFileHistoryEntrySchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    subject: z.string(),
+    body: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string(),
+    // Unix seconds.
+    authoredAt: z.number(),
+    committerName: z.string(),
+    committedAt: z.number(),
+    // The file's name at this commit - differs from the requested path across a
+    // rename. Diff requests must echo this one back, not the current name.
+    path: z.string(),
+    previousPath: z.string().optional(),
+    // Single-letter git status (A/M/D/R/C).
+    changeKind: z.string().optional(),
+    isMerge: z.boolean(),
+    // Parent object names, so a diff view can name the revision it is comparing
+    // against instead of writing "<sha>^". Empty for a root commit.
+    parentShas: z.array(z.string()).optional(),
+});
+export const GitBlameLineSchema = z.object({
+    line: z.number(),
+    sha: z.string(),
+    originalLine: z.number(),
+});
+// Blame commit metadata is deduped by sha rather than inlined per line: a
+// thousand-line page usually references a handful of commits.
+export const GitBlameCommitSchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    summary: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string(),
+    authoredAt: z.number(),
+    path: z.string().optional(),
+});
+//# sourceMappingURL=git-operations.js.map

package/dist/integration-authorization.d.ts

@@ -0,0 +1,195 @@
+import { z } from "zod";
+/** Nonsecret credential methods Otto may present through one Connect flow. */
+export declare const IntegrationAuthorizationMethodSchema: z.ZodString;
+/**
+ * Lifecycle state safe to project to a frontend. Secrets and callback material
+ * deliberately have no schema here, so they cannot leak through this contract.
+ */
+export declare const IntegrationConnectionStateSchema: z.ZodEnum<{
+    error: "error";
+    disconnected: "disconnected";
+    connected: "connected";
+    reauth_required: "reauth_required";
+    authorizing: "authorizing";
+}>;
+export declare const IntegrationConnectionMetadataSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    connectionId: z.ZodString;
+    method: z.ZodString;
+    state: z.ZodEnum<{
+        error: "error";
+        disconnected: "disconnected";
+        connected: "connected";
+        reauth_required: "reauth_required";
+        authorizing: "authorizing";
+    }>;
+    accountLabel: z.ZodNullable<z.ZodString>;
+    grantedScopes: z.ZodArray<z.ZodString>;
+    updatedAt: z.ZodString;
+    errorCode: z.ZodNullable<z.ZodString>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** A host-safe projection of whether secure storage can accept credentials. */
+export declare const CredentialVaultAvailabilitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    backend: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodString;
+}, z.core.$strip>], "status">;
+/**
+ * The settings-safe authorization projection. It is deliberately limited to
+ * connection metadata and vault readiness: browser callbacks and credentials
+ * never cross this boundary.
+ */
+export declare const IntegrationAuthorizationOverviewSchema: z.ZodObject<{
+    vault: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        backend: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+    connections: z.ZodArray<z.ZodObject<{
+        integrationId: z.ZodString;
+        connectionId: z.ZodString;
+        method: z.ZodString;
+        state: z.ZodEnum<{
+            error: "error";
+            disconnected: "disconnected";
+            connected: "connected";
+            reauth_required: "reauth_required";
+            authorizing: "authorizing";
+        }>;
+        accountLabel: z.ZodNullable<z.ZodString>;
+        grantedScopes: z.ZodArray<z.ZodString>;
+        updatedAt: z.ZodString;
+        errorCode: z.ZodNullable<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * A nonsecret connection choice rendered by a future Integration settings
+ * surface. The method is intentionally a string rather than an enum so new
+ * providers can add a legitimate OAuth/device/API-key flow without breaking an
+ * older wire parser.
+ */
+export declare const IntegrationAuthorizationMethodOptionSchema: z.ZodObject<{
+    integrationId: z.ZodString;
+    method: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+    recommended: z.ZodBoolean;
+    availability: z.ZodEnum<{
+        available: "available";
+        planned: "planned";
+    }>;
+}, z.core.$strip>;
+export type IntegrationAuthorizationMethod = z.infer<typeof IntegrationAuthorizationMethodSchema>;
+export type IntegrationConnectionState = z.infer<typeof IntegrationConnectionStateSchema>;
+export type IntegrationConnectionMetadata = z.infer<typeof IntegrationConnectionMetadataSchema>;
+export type CredentialVaultAvailability = z.infer<typeof CredentialVaultAvailabilitySchema>;
+export type IntegrationAuthorizationOverview = z.infer<typeof IntegrationAuthorizationOverviewSchema>;
+export type IntegrationAuthorizationMethodOption = z.infer<typeof IntegrationAuthorizationMethodOptionSchema>;
+export declare const IntegrationsAuthorizationGetOverviewRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.authorization.get_overview.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const IntegrationsAuthorizationGetOverviewResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.authorization.get_overview.response">;
+    payload: z.ZodObject<{
+        overview: z.ZodObject<{
+            vault: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                backend: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "status">;
+            connections: z.ZodArray<z.ZodObject<{
+                integrationId: z.ZodString;
+                connectionId: z.ZodString;
+                method: z.ZodString;
+                state: z.ZodEnum<{
+                    error: "error";
+                    disconnected: "disconnected";
+                    connected: "connected";
+                    reauth_required: "reauth_required";
+                    authorizing: "authorizing";
+                }>;
+                accountLabel: z.ZodNullable<z.ZodString>;
+                grantedScopes: z.ZodArray<z.ZodString>;
+                updatedAt: z.ZodString;
+                errorCode: z.ZodNullable<z.ZodString>;
+                enabled: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntegrationsAuthorizationGetOverviewRequest = z.infer<typeof IntegrationsAuthorizationGetOverviewRequestSchema>;
+export type IntegrationsAuthorizationGetOverviewResponse = z.infer<typeof IntegrationsAuthorizationGetOverviewResponseSchema>;
+/**
+ * List daemon-supported, nonsecret authorization methods for integration
+ * settings. Availability is explicit so a client never offers a flow the host
+ * has not implemented yet. Gated by features.integrationAuthorization.
+ */
+export declare const IntegrationsAuthorizationGetMethodsRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.authorization.get_methods.request">;
+    requestId: z.ZodString;
+    integrationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const IntegrationsAuthorizationGetMethodsResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.authorization.get_methods.response">;
+    payload: z.ZodObject<{
+        methods: z.ZodArray<z.ZodObject<{
+            integrationId: z.ZodString;
+            method: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodString;
+            recommended: z.ZodBoolean;
+            availability: z.ZodEnum<{
+                available: "available";
+                planned: "planned";
+            }>;
+        }, z.core.$strip>>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntegrationsAuthorizationGetMethodsRequest = z.infer<typeof IntegrationsAuthorizationGetMethodsRequestSchema>;
+export type IntegrationsAuthorizationGetMethodsResponse = z.infer<typeof IntegrationsAuthorizationGetMethodsResponseSchema>;
+/**
+ * Starts a daemon-owned browser sign-in through the registered integration
+ * driver. Authorization codes and credentials remain daemon-only.
+ * Gated by features.integrationAuthorizationBrowserFlow.
+ */
+export declare const IntegrationsAuthorizationStartBrowserRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.authorization.start_browser.request">;
+    requestId: z.ZodString;
+    integrationId: z.ZodString;
+    connectionId: z.ZodString;
+}, z.core.$strip>;
+export declare const IntegrationsAuthorizationStartBrowserResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.authorization.start_browser.response">;
+    payload: z.ZodObject<{
+        authorizationUrl: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntegrationsAuthorizationStartBrowserResponse = z.infer<typeof IntegrationsAuthorizationStartBrowserResponseSchema>;
+/** Starts the configured daemon-owned Zoom PKCE browser flow. */
+export declare const IntegrationsZoomStartAuthorizationRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.zoom.start_authorization.request">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
+export declare const IntegrationsZoomStartAuthorizationResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"integrations.zoom.start_authorization.response">;
+    payload: z.ZodObject<{
+        authorizationUrl: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+        requestId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type IntegrationsZoomStartAuthorizationResponse = z.infer<typeof IntegrationsZoomStartAuthorizationResponseSchema>;
+//# sourceMappingURL=integration-authorization.d.ts.map

package/dist/integration-authorization.js

@@ -0,0 +1,125 @@
+import { z } from "zod";
+/** Nonsecret credential methods Otto may present through one Connect flow. */
+export const IntegrationAuthorizationMethodSchema = z.string().trim().min(1);
+/**
+ * Lifecycle state safe to project to a frontend. Secrets and callback material
+ * deliberately have no schema here, so they cannot leak through this contract.
+ */
+export const IntegrationConnectionStateSchema = z.enum([
+    "disconnected",
+    "authorizing",
+    "connected",
+    "reauth_required",
+    "error",
+]);
+export const IntegrationConnectionMetadataSchema = z.object({
+    integrationId: z.string().trim().min(1),
+    connectionId: z.string().trim().min(1),
+    method: IntegrationAuthorizationMethodSchema,
+    state: IntegrationConnectionStateSchema,
+    accountLabel: z.string().nullable(),
+    grantedScopes: z.array(z.string()),
+    updatedAt: z.string().datetime(),
+    errorCode: z.string().nullable(),
+    /** Nonsecret daemon-owned availability, independent of authorization state. */
+    enabled: z.boolean().optional(),
+});
+/** A host-safe projection of whether secure storage can accept credentials. */
+export const CredentialVaultAvailabilitySchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("available"),
+        backend: z.string().trim().min(1),
+    }),
+    z.object({
+        status: z.literal("unavailable"),
+        reason: z.string().trim().min(1),
+    }),
+]);
+/**
+ * The settings-safe authorization projection. It is deliberately limited to
+ * connection metadata and vault readiness: browser callbacks and credentials
+ * never cross this boundary.
+ */
+export const IntegrationAuthorizationOverviewSchema = z.object({
+    vault: CredentialVaultAvailabilitySchema,
+    connections: z.array(IntegrationConnectionMetadataSchema),
+});
+/**
+ * A nonsecret connection choice rendered by a future Integration settings
+ * surface. The method is intentionally a string rather than an enum so new
+ * providers can add a legitimate OAuth/device/API-key flow without breaking an
+ * older wire parser.
+ */
+export const IntegrationAuthorizationMethodOptionSchema = z.object({
+    integrationId: z.string().trim().min(1),
+    method: IntegrationAuthorizationMethodSchema,
+    label: z.string().trim().min(1),
+    description: z.string().trim().min(1),
+    recommended: z.boolean(),
+    availability: z.enum(["available", "planned"]),
+});
+// Settings pages use this generic, daemon-owned projection to render reusable
+// integration connection state. OAuth drivers and API-key entry remain outside
+// the wire contract until their provider-specific implementation exists.
+// Gated by features.integrationAuthorization.
+export const IntegrationsAuthorizationGetOverviewRequestSchema = z.object({
+    type: z.literal("integrations.authorization.get_overview.request"),
+    requestId: z.string(),
+});
+export const IntegrationsAuthorizationGetOverviewResponseSchema = z.object({
+    type: z.literal("integrations.authorization.get_overview.response"),
+    payload: z.object({
+        overview: IntegrationAuthorizationOverviewSchema,
+        requestId: z.string(),
+    }),
+});
+/**
+ * List daemon-supported, nonsecret authorization methods for integration
+ * settings. Availability is explicit so a client never offers a flow the host
+ * has not implemented yet. Gated by features.integrationAuthorization.
+ */
+export const IntegrationsAuthorizationGetMethodsRequestSchema = z.object({
+    type: z.literal("integrations.authorization.get_methods.request"),
+    requestId: z.string(),
+    integrationId: z.string().optional(),
+});
+export const IntegrationsAuthorizationGetMethodsResponseSchema = z.object({
+    type: z.literal("integrations.authorization.get_methods.response"),
+    payload: z.object({
+        methods: z.array(IntegrationAuthorizationMethodOptionSchema),
+        requestId: z.string(),
+    }),
+});
+/**
+ * Starts a daemon-owned browser sign-in through the registered integration
+ * driver. Authorization codes and credentials remain daemon-only.
+ * Gated by features.integrationAuthorizationBrowserFlow.
+ */
+export const IntegrationsAuthorizationStartBrowserRequestSchema = z.object({
+    type: z.literal("integrations.authorization.start_browser.request"),
+    requestId: z.string(),
+    integrationId: z.string(),
+    connectionId: z.string(),
+});
+export const IntegrationsAuthorizationStartBrowserResponseSchema = z.object({
+    type: z.literal("integrations.authorization.start_browser.response"),
+    payload: z.object({
+        authorizationUrl: z.string().url().nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+/** Starts the configured daemon-owned Zoom PKCE browser flow. */
+export const IntegrationsZoomStartAuthorizationRequestSchema = z.object({
+    type: z.literal("integrations.zoom.start_authorization.request"),
+    requestId: z.string(),
+});
+export const IntegrationsZoomStartAuthorizationResponseSchema = z.object({
+    type: z.literal("integrations.zoom.start_authorization.response"),
+    payload: z.object({
+        authorizationUrl: z.string().url().nullable(),
+        error: z.string().nullable(),
+        requestId: z.string(),
+    }),
+});
+//# sourceMappingURL=integration-authorization.js.map