@otto-code/server 0.5.0

package/dist/server/server/workspace-registry-model.js

@@ -0,0 +1,190 @@
+import { randomBytes } from "node:crypto";
+import { resolve } from "node:path";
+import { parseGitRevParsePath } from "../utils/git-rev-parse-path.js";
+export function generateWorkspaceId() {
+    return `wks_${randomBytes(8).toString("hex")}`;
+}
+// Path-derived grouping key for a workspace directory. This is NOT the opaque
+// workspace identity (see generateWorkspaceId); never persist or compare it as one.
+export function deriveWorkspaceDirectoryKey(cwd, checkout) {
+    const worktreeRoot = checkout.worktreeRoot ? parseGitRevParsePath(checkout.worktreeRoot) : null;
+    return worktreeRoot ?? resolve(cwd);
+}
+function deriveRemoteProjectKey(remoteUrl) {
+    if (!remoteUrl) {
+        return null;
+    }
+    const trimmed = remoteUrl.trim();
+    if (!trimmed) {
+        return null;
+    }
+    let host = null;
+    let remotePath = null;
+    const scpLike = trimmed.match(/^[^@]+@([^:]+):(.+)$/);
+    if (scpLike) {
+        host = scpLike[1] ?? null;
+        remotePath = scpLike[2] ?? null;
+    }
+    else if (trimmed.includes("://")) {
+        try {
+            const parsed = new URL(trimmed);
+            host = parsed.hostname || null;
+            remotePath = parsed.pathname ? parsed.pathname.replace(/^\/+/, "") : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (!host || !remotePath) {
+        return null;
+    }
+    let cleanedPath = remotePath.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+    if (cleanedPath.endsWith(".git")) {
+        cleanedPath = cleanedPath.slice(0, -4);
+    }
+    if (!cleanedPath.includes("/")) {
+        return null;
+    }
+    const cleanedHost = host.toLowerCase();
+    if (cleanedHost === "github.com") {
+        return `remote:github.com/${cleanedPath}`;
+    }
+    return `remote:${cleanedHost}/${cleanedPath}`;
+}
+export function deriveProjectGroupingKey(options) {
+    const remoteKey = deriveRemoteProjectKey(options.remoteUrl);
+    if (remoteKey) {
+        return remoteKey;
+    }
+    const mainRepoRoot = options.mainRepoRoot?.trim();
+    if (mainRepoRoot) {
+        return mainRepoRoot;
+    }
+    return options.cwd;
+}
+export function deriveProjectGroupingName(projectKey) {
+    if (projectKey.startsWith("remote:")) {
+        const remainder = projectKey.slice("remote:".length);
+        const pathSegments = remainder.split("/").filter(Boolean).slice(1);
+        if (pathSegments.length >= 2) {
+            return pathSegments.slice(-2).join("/");
+        }
+        if (pathSegments.length === 1) {
+            return pathSegments[0];
+        }
+        return projectKey;
+    }
+    const segments = projectKey.split(/[\\/]/).filter(Boolean);
+    return segments[segments.length - 1] || projectKey;
+}
+function deriveWorkspaceDirectoryName(cwd) {
+    const normalized = cwd.replace(/\\/g, "/");
+    const segments = normalized.split("/").filter(Boolean);
+    return segments[segments.length - 1] ?? cwd;
+}
+export function deriveWorkspaceDisplayName(input) {
+    const branch = input.checkout.currentBranch?.trim() ?? null;
+    if (branch && branch.toUpperCase() !== "HEAD") {
+        return branch;
+    }
+    return deriveWorkspaceDirectoryName(input.cwd);
+}
+export function deriveProjectRootPath(input) {
+    if (input.checkout.isGit && input.checkout.mainRepoRoot) {
+        return input.checkout.mainRepoRoot;
+    }
+    return input.cwd;
+}
+export function deriveProjectKind(checkout) {
+    return checkout.isGit ? "git" : "non_git";
+}
+export function deriveWorkspaceKind(checkout) {
+    if (!checkout.isGit) {
+        return "directory";
+    }
+    return checkout.mainRepoRoot ? "worktree" : "local_checkout";
+}
+export function checkoutLiteFromGitSnapshot(cwd, git) {
+    if (!git.isGit) {
+        return {
+            cwd,
+            isGit: false,
+            currentBranch: null,
+            remoteUrl: null,
+            worktreeRoot: null,
+            isOttoOwnedWorktree: false,
+            mainRepoRoot: null,
+        };
+    }
+    if (git.isOttoOwnedWorktree && git.mainRepoRoot) {
+        return {
+            cwd,
+            isGit: true,
+            currentBranch: git.currentBranch,
+            remoteUrl: git.remoteUrl,
+            worktreeRoot: git.repoRoot ?? cwd,
+            isOttoOwnedWorktree: true,
+            mainRepoRoot: git.mainRepoRoot,
+        };
+    }
+    return {
+        cwd,
+        isGit: true,
+        currentBranch: git.currentBranch,
+        remoteUrl: git.remoteUrl,
+        worktreeRoot: git.repoRoot ?? cwd,
+        isOttoOwnedWorktree: false,
+        mainRepoRoot: git.mainRepoRoot,
+    };
+}
+export async function detectStaleWorkspaces(input) {
+    const staleWorkspaceIds = new Set();
+    const existenceChecks = await Promise.all(input.activeWorkspaces.map(async (workspace) => ({
+        workspace,
+        exists: await input.checkDirectoryExists(workspace.cwd),
+    })));
+    for (const { workspace, exists } of existenceChecks) {
+        if (!exists) {
+            staleWorkspaceIds.add(workspace.workspaceId);
+        }
+    }
+    return staleWorkspaceIds;
+}
+export function buildProjectPlacementForCwd(input) {
+    const membership = classifyDirectoryForProjectMembership(input);
+    return {
+        projectKey: membership.projectKey,
+        projectName: membership.projectName,
+        checkout: membership.checkout,
+    };
+}
+export function classifyDirectoryForProjectMembership(input) {
+    const normalizedCwd = resolve(input.cwd);
+    const checkout = {
+        ...input.checkout,
+        cwd: normalizedCwd,
+    };
+    const projectKey = deriveProjectGroupingKey({
+        cwd: checkout.worktreeRoot ?? normalizedCwd,
+        remoteUrl: checkout.remoteUrl,
+        mainRepoRoot: checkout.mainRepoRoot,
+    });
+    return {
+        cwd: normalizedCwd,
+        checkout,
+        workspaceDirectoryKey: deriveWorkspaceDirectoryKey(normalizedCwd, checkout),
+        workspaceKind: deriveWorkspaceKind(checkout),
+        workspaceDisplayName: deriveWorkspaceDisplayName({
+            cwd: normalizedCwd,
+            checkout,
+        }),
+        projectKey,
+        projectName: deriveProjectGroupingName(projectKey),
+        projectRootPath: deriveProjectRootPath({
+            cwd: normalizedCwd,
+            checkout,
+        }),
+        projectKind: deriveProjectKind(checkout),
+    };
+}
+//# sourceMappingURL=workspace-registry-model.js.map

package/dist/server/server/workspace-registry.d.ts

@@ -0,0 +1,117 @@
+import type { Logger } from "pino";
+import { z } from "zod";
+import type { PersistedProjectKind, PersistedWorkspaceKind } from "./workspace-registry-model.js";
+declare const PersistedProjectRecordSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    rootPath: z.ZodString;
+    kind: z.ZodEnum<{
+        git: "git";
+        non_git: "non_git";
+    }>;
+    displayName: z.ZodString;
+    customName: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    archivedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    projectId: z.ZodString;
+    cwd: z.ZodString;
+    kind: z.ZodEnum<{
+        local_checkout: "local_checkout";
+        worktree: "worktree";
+        directory: "directory";
+    }>;
+    displayName: z.ZodString;
+    title: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    branch: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    baseBranch: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodString>>, z.ZodTransform<string | null, string | null | undefined>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    archivedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type PersistedProjectRecord = z.infer<typeof PersistedProjectRecordSchema>;
+export type PersistedWorkspaceRecord = z.infer<typeof PersistedWorkspaceRecordSchema>;
+export interface ProjectRegistry {
+    initialize(): Promise<void>;
+    existsOnDisk(): Promise<boolean>;
+    list(): Promise<PersistedProjectRecord[]>;
+    get(projectId: string): Promise<PersistedProjectRecord | null>;
+    upsert(record: PersistedProjectRecord): Promise<void>;
+    archive(projectId: string, archivedAt: string): Promise<void>;
+    remove(projectId: string): Promise<void>;
+}
+export interface WorkspaceRegistry {
+    initialize(): Promise<void>;
+    existsOnDisk(): Promise<boolean>;
+    list(): Promise<PersistedWorkspaceRecord[]>;
+    get(workspaceId: string): Promise<PersistedWorkspaceRecord | null>;
+    upsert(record: PersistedWorkspaceRecord): Promise<void>;
+    archive(workspaceId: string, archivedAt: string): Promise<void>;
+    remove(workspaceId: string): Promise<void>;
+}
+type RegistryRecord = PersistedProjectRecord | PersistedWorkspaceRecord;
+declare class FileBackedRegistry<TRecord extends RegistryRecord> {
+    private readonly filePath;
+    private readonly logger;
+    private readonly schema;
+    private readonly getId;
+    private loaded;
+    private readonly cache;
+    private persistQueue;
+    constructor(options: {
+        filePath: string;
+        logger: Logger;
+        schema: z.ZodType<TRecord, unknown>;
+        getId: (record: TRecord) => string;
+        component: string;
+    });
+    initialize(): Promise<void>;
+    existsOnDisk(): Promise<boolean>;
+    list(): Promise<TRecord[]>;
+    get(id: string): Promise<TRecord | null>;
+    upsert(record: TRecord): Promise<void>;
+    archive(id: string, archivedAt: string): Promise<void>;
+    remove(id: string): Promise<void>;
+    private load;
+    private persist;
+    private enqueuePersist;
+}
+export declare class FileBackedProjectRegistry extends FileBackedRegistry<PersistedProjectRecord> implements ProjectRegistry {
+    constructor(filePath: string, logger: Logger);
+}
+export declare class FileBackedWorkspaceRegistry extends FileBackedRegistry<PersistedWorkspaceRecord> implements WorkspaceRegistry {
+    constructor(filePath: string, logger: Logger);
+}
+export declare function createPersistedProjectRecord(input: {
+    projectId: string;
+    rootPath: string;
+    kind: PersistedProjectKind;
+    displayName: string;
+    customName?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string | null;
+}): PersistedProjectRecord;
+export declare function resolveProjectDisplayName(record: PersistedProjectRecord): string;
+export declare function createPersistedWorkspaceRecord(input: {
+    workspaceId: string;
+    projectId: string;
+    cwd: string;
+    kind: PersistedWorkspaceKind;
+    displayName: string;
+    title?: string | null;
+    branch?: string | null;
+    baseBranch?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt?: string | null;
+}): PersistedWorkspaceRecord;
+export declare function resolveWorkspaceName(input: {
+    title: string | null;
+    derivedDisplayName: string;
+}): string;
+export declare function resolveWorkspaceDisplayName(record: PersistedWorkspaceRecord): string;
+export {};
+//# sourceMappingURL=workspace-registry.d.ts.map

package/dist/server/server/workspace-registry.js

@@ -0,0 +1,194 @@
+import { promises as fs } from "node:fs";
+import { z } from "zod";
+import { writeJsonFileAtomic } from "./atomic-file.js";
+const PersistedProjectRecordSchema = z.object({
+    projectId: z.string(),
+    rootPath: z.string(),
+    kind: z.enum(["git", "non_git"]),
+    displayName: z.string(),
+    // User-set override layered over the derived displayName. Reconciliation
+    // never touches this. Null means "use the derived name". Added for #987.
+    customName: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    archivedAt: z.string().nullable(),
+});
+const PersistedWorkspaceRecordSchema = z.object({
+    workspaceId: z.string(),
+    projectId: z.string(),
+    cwd: z.string(),
+    kind: z.enum(["local_checkout", "worktree", "directory"]),
+    displayName: z.string(),
+    // User-set title layered over the derived displayName. In Model B the title is
+    // the workspace identity; branch/directory are backing metadata. Reconciliation
+    // never touches this. Null means "use the derived displayName".
+    title: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
+    // The worktree's git branch. Decoupled from displayName/title by construction:
+    // displayName holds the human name (title), branch holds the git branch. Only
+    // worktree workspaces carry a branch; directory/local_checkout leave it null.
+    branch: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
+    // The base branch the worktree was created from (normalized like worktree.json's
+    // baseRefName). Only worktree workspaces carry a base branch; checkout-branch
+    // worktrees and directory/local_checkout workspaces leave it null.
+    baseBranch: z
+        .string()
+        .nullable()
+        .optional()
+        .transform((value) => value ?? null),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    archivedAt: z.string().nullable(),
+});
+class FileBackedRegistry {
+    constructor(options) {
+        this.loaded = false;
+        this.cache = new Map();
+        this.persistQueue = Promise.resolve();
+        this.filePath = options.filePath;
+        this.schema = options.schema;
+        this.getId = options.getId;
+        this.logger = options.logger.child({
+            module: "workspace-registry",
+            component: options.component,
+        });
+    }
+    async initialize() {
+        await this.load();
+    }
+    async existsOnDisk() {
+        try {
+            await fs.access(this.filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async list() {
+        await this.load();
+        return Array.from(this.cache.values());
+    }
+    async get(id) {
+        await this.load();
+        return this.cache.get(id) ?? null;
+    }
+    async upsert(record) {
+        await this.load();
+        const parsed = this.schema.parse(record);
+        this.cache.set(this.getId(parsed), parsed);
+        await this.enqueuePersist();
+    }
+    async archive(id, archivedAt) {
+        await this.load();
+        const existing = this.cache.get(id);
+        if (!existing) {
+            return;
+        }
+        const next = this.schema.parse({
+            ...existing,
+            updatedAt: archivedAt,
+            archivedAt,
+        });
+        this.cache.set(id, next);
+        await this.enqueuePersist();
+    }
+    async remove(id) {
+        await this.load();
+        if (!this.cache.delete(id)) {
+            return;
+        }
+        await this.enqueuePersist();
+    }
+    async load() {
+        if (this.loaded) {
+            return;
+        }
+        this.cache.clear();
+        try {
+            const raw = await fs.readFile(this.filePath, "utf8");
+            const parsed = z.array(this.schema).parse(JSON.parse(raw));
+            for (const record of parsed) {
+                this.cache.set(this.getId(record), record);
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT") {
+                this.logger.error({ err: error, filePath: this.filePath }, "Failed to load registry file");
+            }
+        }
+        this.loaded = true;
+    }
+    async persist() {
+        const records = Array.from(this.cache.values());
+        await writeJsonFileAtomic(this.filePath, records);
+    }
+    async enqueuePersist() {
+        const nextPersist = this.persistQueue.then(() => this.persist());
+        this.persistQueue = nextPersist.catch(() => { });
+        await nextPersist;
+    }
+}
+export class FileBackedProjectRegistry extends FileBackedRegistry {
+    constructor(filePath, logger) {
+        super({
+            filePath,
+            logger,
+            schema: PersistedProjectRecordSchema,
+            getId: (record) => record.projectId,
+            component: "projects",
+        });
+    }
+}
+export class FileBackedWorkspaceRegistry extends FileBackedRegistry {
+    constructor(filePath, logger) {
+        super({
+            filePath,
+            logger,
+            schema: PersistedWorkspaceRecordSchema,
+            getId: (record) => record.workspaceId,
+            component: "workspaces",
+        });
+    }
+}
+export function createPersistedProjectRecord(input) {
+    return PersistedProjectRecordSchema.parse({
+        ...input,
+        customName: input.customName ?? null,
+        archivedAt: input.archivedAt ?? null,
+    });
+}
+export function resolveProjectDisplayName(record) {
+    return record.customName ?? record.displayName;
+}
+export function createPersistedWorkspaceRecord(input) {
+    return PersistedWorkspaceRecordSchema.parse({
+        ...input,
+        title: input.title ?? null,
+        branch: input.branch ?? null,
+        baseBranch: input.baseBranch ?? null,
+        archivedAt: input.archivedAt ?? null,
+    });
+}
+// The single workspace-name rule: the title always wins; otherwise fall back to
+// the freshest available derived display name (a live branch snapshot when the
+// caller has one, the persisted displayName otherwise).
+export function resolveWorkspaceName(input) {
+    return input.title ?? input.derivedDisplayName;
+}
+export function resolveWorkspaceDisplayName(record) {
+    return resolveWorkspaceName({ title: record.title, derivedDisplayName: record.displayName });
+}
+//# sourceMappingURL=workspace-registry.js.map

package/dist/server/server/workspace-script-runtime-store.d.ts

@@ -0,0 +1,28 @@
+export interface ScriptRuntimeEntry {
+    workspaceId: string;
+    scriptName: string;
+    type: "script" | "service";
+    lifecycle: "running" | "stopped";
+    terminalId: string;
+    exitCode: number | null;
+}
+interface RuntimeEntryKey {
+    workspaceId: string;
+    scriptName: string;
+}
+export declare class WorkspaceScriptRuntimeStore {
+    private readonly entries;
+    private readonly scriptsByWorkspace;
+    get(key: RuntimeEntryKey): ScriptRuntimeEntry | null;
+    set(entry: ScriptRuntimeEntry): void;
+    remove(key: RuntimeEntryKey): void;
+    listForWorkspace(workspaceId: string): ScriptRuntimeEntry[];
+    removeForWorkspace(workspaceId: string): void;
+    isRunning(key: RuntimeEntryKey): boolean;
+    private addScriptToWorkspaceIndex;
+    private removeScriptFromWorkspaceIndex;
+    private toEntryKey;
+    private toWorkspaceKey;
+}
+export {};
+//# sourceMappingURL=workspace-script-runtime-store.d.ts.map

package/dist/server/server/workspace-script-runtime-store.js

@@ -0,0 +1,78 @@
+export class WorkspaceScriptRuntimeStore {
+    constructor() {
+        this.entries = new Map();
+        this.scriptsByWorkspace = new Map();
+    }
+    get(key) {
+        const entry = this.entries.get(this.toEntryKey(key));
+        return entry ? { ...entry } : null;
+    }
+    set(entry) {
+        const workspaceKey = this.toWorkspaceKey(entry.workspaceId);
+        const entryKey = this.toEntryKey(entry);
+        const previous = this.entries.get(entryKey);
+        if (previous) {
+            this.removeScriptFromWorkspaceIndex(previous.workspaceId, previous.scriptName);
+        }
+        this.entries.set(entryKey, { ...entry });
+        this.addScriptToWorkspaceIndex(workspaceKey, entry.scriptName);
+    }
+    remove(key) {
+        const entryKey = this.toEntryKey(key);
+        const existing = this.entries.get(entryKey);
+        if (!existing) {
+            return;
+        }
+        this.entries.delete(entryKey);
+        this.removeScriptFromWorkspaceIndex(existing.workspaceId, existing.scriptName);
+    }
+    listForWorkspace(workspaceId) {
+        const scriptNames = this.scriptsByWorkspace.get(this.toWorkspaceKey(workspaceId));
+        if (!scriptNames) {
+            return [];
+        }
+        const entries = [];
+        for (const scriptName of scriptNames) {
+            const entry = this.entries.get(this.toEntryKey({
+                workspaceId,
+                scriptName,
+            }));
+            if (entry) {
+                entries.push({ ...entry });
+            }
+        }
+        return entries;
+    }
+    removeForWorkspace(workspaceId) {
+        for (const entry of this.listForWorkspace(workspaceId)) {
+            this.entries.delete(this.toEntryKey(entry));
+        }
+        this.scriptsByWorkspace.delete(this.toWorkspaceKey(workspaceId));
+    }
+    isRunning(key) {
+        return this.get(key)?.lifecycle === "running";
+    }
+    addScriptToWorkspaceIndex(workspaceKey, scriptName) {
+        const scripts = this.scriptsByWorkspace.get(workspaceKey) ?? new Set();
+        scripts.add(scriptName);
+        this.scriptsByWorkspace.set(workspaceKey, scripts);
+    }
+    removeScriptFromWorkspaceIndex(workspaceId, scriptName) {
+        const workspaceKey = this.toWorkspaceKey(workspaceId);
+        const scripts = this.scriptsByWorkspace.get(workspaceKey);
+        if (!scripts) {
+            return;
+        }
+        scripts.delete(scriptName);
+        if (scripts.size === 0) {
+            this.scriptsByWorkspace.delete(workspaceKey);
+        }
+    }
+    toEntryKey(key) {
+        return `${this.toWorkspaceKey(key.workspaceId)}::${key.scriptName}`;
+    }
+    toWorkspaceKey(workspaceId) {
+        return workspaceId;
+    }
+}
+//# sourceMappingURL=workspace-script-runtime-store.js.map

package/dist/server/server/workspace-service-env.d.ts

@@ -0,0 +1,18 @@
+export interface WorkspaceServicePeer {
+    scriptName: string;
+    port: number;
+}
+export interface BuildWorkspaceServiceEnvOptions {
+    scriptName: string;
+    projectSlug: string;
+    branchName: string | null;
+    daemonPort: number | null | undefined;
+    daemonListenHost: string | null | undefined;
+    serviceProxyPublicBaseUrl?: string | null;
+    peers: readonly WorkspaceServicePeer[];
+}
+export declare function normalizeServiceEnvName(scriptName: string): string;
+export declare function buildWorkspaceServiceEnv(options: BuildWorkspaceServiceEnvOptions): Record<string, string>;
+export declare function resolveServiceBindHost(daemonListenHost: string | null | undefined): string;
+export declare function assertNoServiceEnvNameCollisions(scriptNames: readonly string[]): void;
+//# sourceMappingURL=workspace-service-env.d.ts.map