@otto-code/protocol 0.5.0

package/dist/git-hosting.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const GitHostingProviderIdSchema: z.ZodEnum<{
+    github: "github";
+    "bitbucket-cloud": "bitbucket-cloud";
+}>;
+export declare const GitHostingProviderIdWireSchema: z.ZodString;
+export declare const GitHostingCapabilitiesSchema: z.ZodObject<{
+    autoMerge: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    mergeQueue: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    checkAnnotations: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    checkDetails: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    draftPrs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    reviewDecisions: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    issues: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type GitHostingProviderId = z.infer<typeof GitHostingProviderIdSchema>;
+export type GitHostingCapabilities = z.infer<typeof GitHostingCapabilitiesSchema>;
+export declare const GIT_HOSTING_PROVIDER_IDS: ("github" | "bitbucket-cloud")[];
+export declare function isGitHostingProviderId(value: unknown): value is GitHostingProviderId;
+export declare function normalizeGitHostingProviderId(value: string | null | undefined): GitHostingProviderId | null;
+//# sourceMappingURL=git-hosting.d.ts.map

package/dist/git-hosting.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+// ── Git hosting providers ────────────────────────────────────────────────
+// A project's git hosting provider (GitHub, Bitbucket Cloud, ...) is chosen
+// per project in otto.json; all PR/issue functionality follows that choice.
+// Shared by messages.ts (wire schemas) and otto-config-schema.ts (project
+// config) — lives here to avoid a module cycle between those two.
+export const GitHostingProviderIdSchema = z.enum(["github", "bitbucket-cloud"]);
+// Wire form of the provider id. Deliberately an OPEN string, not the enum, so a
+// newer peer that adds a third provider (e.g. "gitlab") never makes an older
+// peer's validator drop the whole message. Consumers normalize to the known set
+// with normalizeGitHostingProviderId (mirrors normalizePersonalityRoles) and
+// degrade gracefully for unknown ids. Keep the enum for otto.json config and the
+// GIT_HOSTING_PROVIDER_IDS known-set.
+export const GitHostingProviderIdWireSchema = z.string();
+// What a provider can do. The client renders only capability-true actions —
+// no emulation of missing features (feature contract).
+export const GitHostingCapabilitiesSchema = z.object({
+    autoMerge: z.boolean().optional().default(false),
+    mergeQueue: z.boolean().optional().default(false),
+    checkAnnotations: z.boolean().optional().default(false),
+    checkDetails: z.boolean().optional().default(false),
+    draftPrs: z.boolean().optional().default(false),
+    reviewDecisions: z.boolean().optional().default(false),
+    issues: z.boolean().optional().default(false),
+});
+export const GIT_HOSTING_PROVIDER_IDS = GitHostingProviderIdSchema.options;
+export function isGitHostingProviderId(value) {
+    return GitHostingProviderIdSchema.safeParse(value).success;
+}
+// Narrow an open wire provider id to the known set, or null when it's a provider
+// this build doesn't recognize (a message from a newer peer). Callers render a
+// neutral fallback for null rather than dropping the message.
+export function normalizeGitHostingProviderId(value) {
+    return isGitHostingProviderId(value) ? value : null;
+}
+//# sourceMappingURL=git-hosting.js.map

package/dist/git-remote.d.ts

@@ -0,0 +1,18 @@
+export interface GitRemoteLocation {
+    transport: "scp" | "ssh" | "http" | "https";
+    host: string;
+    path: string;
+}
+export interface GitHubRemoteIdentity {
+    owner: string;
+    name: string;
+    repo: string;
+}
+export declare function parseGitHubRemoteUrl(remoteUrl: string): GitHubRemoteIdentity | null;
+export declare function isBitbucketCloudHost(host: string): boolean;
+export declare function parseBitbucketCloudRemoteUrl(remoteUrl: string): GitHubRemoteIdentity | null;
+export declare function parseGitRemoteLocation(remoteUrl: string): GitRemoteLocation | null;
+export declare function parseGitHubRemoteIdentity(path: string): GitHubRemoteIdentity | null;
+export declare function isGitHubHost(host: string): boolean;
+export declare function normalizeHost(host: string): string;
+//# sourceMappingURL=git-remote.d.ts.map

package/dist/git-remote.js

@@ -0,0 +1,84 @@
+const GITHUB_HOSTS = new Set(["github.com", "ssh.github.com"]);
+const BITBUCKET_CLOUD_HOSTS = new Set(["bitbucket.org", "altssh.bitbucket.org"]);
+const TRANSPORT_BY_PROTOCOL = {
+    "https:": "https",
+    "http:": "http",
+    "ssh:": "ssh",
+};
+export function parseGitHubRemoteUrl(remoteUrl) {
+    const location = parseGitRemoteLocation(remoteUrl);
+    if (!location || !isGitHubHost(location.host))
+        return null;
+    return parseGitHubRemoteIdentity(location.path);
+}
+export function isBitbucketCloudHost(host) {
+    return BITBUCKET_CLOUD_HOSTS.has(host);
+}
+// Bitbucket Cloud remotes share GitHub's two-segment workspace/repo shape, so
+// identity parsing is common; only host classification differs.
+export function parseBitbucketCloudRemoteUrl(remoteUrl) {
+    const location = parseGitRemoteLocation(remoteUrl);
+    if (!location || !isBitbucketCloudHost(location.host))
+        return null;
+    return parseGitHubRemoteIdentity(location.path);
+}
+export function parseGitRemoteLocation(remoteUrl) {
+    const trimmed = remoteUrl.trim();
+    if (!trimmed)
+        return null;
+    const scpLike = trimmed.match(/^[^@]+@([^:]+):(.+)$/u);
+    if (scpLike) {
+        const host = normalizeHost(scpLike[1] ?? "");
+        const path = normalizeRemotePath(scpLike[2] ?? "");
+        if (!isValidRemoteHost(host) || !path)
+            return null;
+        return { transport: "scp", host, path };
+    }
+    let parsed;
+    try {
+        parsed = new URL(trimmed);
+    }
+    catch {
+        return null;
+    }
+    const transport = TRANSPORT_BY_PROTOCOL[parsed.protocol.toLowerCase()];
+    if (!transport)
+        return null;
+    const host = normalizeHost(parsed.hostname);
+    let path;
+    try {
+        path = decodeURIComponent(parsed.pathname);
+    }
+    catch {
+        return null;
+    }
+    const normalizedPath = normalizeRemotePath(path);
+    if (!isValidRemoteHost(host) || !normalizedPath)
+        return null;
+    return { transport, host, path: normalizedPath };
+}
+export function parseGitHubRemoteIdentity(path) {
+    const segments = path.split("/").filter(Boolean);
+    if (segments.length !== 2)
+        return null;
+    const [owner, name] = segments;
+    if (!owner || !name)
+        return null;
+    return { owner, name, repo: `${owner}/${name}` };
+}
+export function isGitHubHost(host) {
+    return GITHUB_HOSTS.has(host);
+}
+export function normalizeHost(host) {
+    return host.trim().replace(/\.+$/u, "").toLowerCase();
+}
+function normalizeRemotePath(path) {
+    let normalized = path.trim().replace(/^\/+|\/+$/gu, "");
+    if (normalized.endsWith(".git"))
+        normalized = normalized.slice(0, -4);
+    return normalized || null;
+}
+function isValidRemoteHost(host) {
+    return /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/u.test(host);
+}
+//# sourceMappingURL=git-remote.js.map

package/dist/host-connection-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const DirectTcpHostConnectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodLiteral<"directTcp">;
+    endpoint: z.ZodString;
+    useTls: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    password: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DirectTcpHostConnection = z.input<typeof DirectTcpHostConnectionSchema>;
+export type NormalizedDirectTcpHostConnection = z.output<typeof DirectTcpHostConnectionSchema>;
+//# sourceMappingURL=host-connection-schema.d.ts.map

package/dist/host-connection-schema.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const DirectTcpHostConnectionSchema = z.object({
+    id: z.string(),
+    type: z.literal("directTcp"),
+    endpoint: z.string(),
+    useTls: z.boolean().optional().default(false),
+    password: z.string().optional(),
+});
+//# sourceMappingURL=host-connection-schema.js.map

package/dist/literal-union.d.ts

@@ -0,0 +1,2 @@
+export type LiteralUnion<T extends U, U extends string> = T | (U & Record<never, never>);
+//# sourceMappingURL=literal-union.d.ts.map

package/dist/literal-union.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=literal-union.js.map