Initialize project and ignore local references

This commit is contained in:
ZacharyZhang-NY committed 2026-03-15 22:17:07 -04:00
1 parent a11ac3eaba
commit 2af82b6bb3
132 files changed
+29426

No files matched your search

+250
View File
@@ -0,0 +1,250 @@
import { z } from "zod";
import type { CommentRecord, DesktopEvent, ProfileSnapshot } from "./types";
export const IPC_CHANNELS = {
loadSnapshot: "agent-company:load-snapshot",
pickDirectory: "agent-company:pick-directory",
openPath: "agent-company:open-path",
saveCompany: "agent-company:save-company",
setCurrentCompany: "agent-company:set-current-company",
saveConnector: "agent-company:save-connector",
testConnector: "agent-company:test-connector",
saveWorkspace: "agent-company:save-workspace",
saveAgent: "agent-company:save-agent",
saveGoal: "agent-company:save-goal",
saveProject: "agent-company:save-project",
saveTask: "agent-company:save-task",
requestApproval: "agent-company:request-approval",
decideApproval: "agent-company:decide-approval",
saveSecret: "agent-company:save-secret",
startTaskRun: "agent-company:start-task-run",
cancelRun: "agent-company:cancel-run",
getRunLog: "agent-company:get-run-log",
backupProfile: "agent-company:backup-profile",
restoreProfile: "agent-company:restore-profile",
updateSettings: "agent-company:update-settings",
checkForUpdates: "agent-company:check-for-updates",
deleteCompany: "agent-company:delete-company",
deleteAgent: "agent-company:delete-agent",
deleteTask: "agent-company:delete-task",
deleteGoal: "agent-company:delete-goal",
deleteProject: "agent-company:delete-project",
deleteWorkspace: "agent-company:delete-workspace",
deleteApproval: "agent-company:delete-approval",
deleteSecret: "agent-company:delete-secret",
getSidebarBadges: "agent-company:get-sidebar-badges",
listConnectorModels: "agent-company:list-connector-models",
addComment: "agent-company:add-comment",
listComments: "agent-company:list-comments",
setHeartbeat: "agent-company:set-heartbeat",
triggerHeartbeat: "agent-company:trigger-heartbeat",
getApiPort: "agent-company:get-api-port",
rendererEvent: "agent-company:event",
} as const;
const optionalId = z.preprocess(
(value) => (value === "" ? null : value),
z.string().uuid().nullable().optional(),
);
export const companyInputSchema = z.object({
id: optionalId,
name: z.string().min(2).max(80),
description: z.string().max(500).default(""),
status: z.enum(["active", "paused", "archived"]).default("active"),
});
export const connectorInputSchema = z.object({
id: z.enum(["codex_local", "claude_local", "gemini_local", "opencode_local", "kimi_local"]),
command: z.string().min(1),
model: z.string().nullable().optional(),
envBindingText: z.string().default(""),
notes: z.string().default(""),
});
export const workspaceInputSchema = z.object({
id: optionalId,
companyId: z.string().uuid(),
name: z.string().min(2).max(80),
localPath: z.string().min(1),
repoUrl: z.string().default(""),
repoRef: z.string().default(""),
projectId: optionalId,
isPrimary: z.boolean().default(false),
});
export const agentInputSchema = z.object({
id: optionalId,
companyId: z.string().uuid(),
name: z.string().min(2).max(80),
role: z.string().min(2).max(80),
title: z.string().default(""),
reportsTo: optionalId,
connectorId: connectorInputSchema.shape.id,
workspaceId: optionalId,
model: z.string().nullable().optional(),
metadataJson: z.string().default("{}").optional(),
capabilities: z.string().default(""),
budgetMonthlyUsd: z.number().min(0).default(0),
status: z.enum(["idle", "active", "running", "paused", "error", "pending_approval", "terminated"]).default("idle"),
});
export const goalInputSchema = z.object({
id: optionalId,
companyId: z.string().uuid(),
title: z.string().min(2).max(120),
description: z.string().default(""),
parentId: optionalId,
ownerAgentId: optionalId,
status: z.enum(["planned", "active", "achieved", "cancelled"]).default("planned"),
});
export const projectInputSchema = z.object({
id: optionalId,
companyId: z.string().uuid(),
goalId: optionalId,
name: z.string().min(2).max(120),
description: z.string().default(""),
leadAgentId: optionalId,
targetDate: z.string().nullable().optional(),
status: z.enum(["backlog", "planned", "in_progress", "completed", "cancelled"]).default("planned"),
});
export const taskInputSchema = z.object({
id: optionalId,
companyId: z.string().uuid(),
projectId: optionalId,
goalId: optionalId,
parentId: optionalId,
title: z.string().min(2).max(160),
description: z.string().default(""),
assigneeAgentId: optionalId,
workspaceId: optionalId,
priority: z.enum(["critical", "high", "medium", "low"]).default("medium"),
status: z.enum(["backlog", "todo", "in_progress", "in_review", "done", "blocked", "cancelled"]).default("todo"),
});
export const approvalInputSchema = z.object({
companyId: z.string().uuid(),
relatedTaskId: optionalId,
requestedByAgentId: optionalId,
type: z.enum(["hire_agent", "approve_ceo_strategy", "dangerous_command", "secret_access"]),
payloadSummary: z.string().min(2).max(280),
impactSummary: z.string().min(2).max(400),
});
export const approvalDecisionSchema = z.object({
approvalId: z.string().uuid(),
state: z.enum(["approved", "rejected", "revision_requested"]),
decisionNote: z.string().max(400).default(""),
});
export const secretInputSchema = z.object({
id: optionalId,
companyId: z.string().uuid(),
name: z.string().min(2).max(80),
description: z.string().default(""),
value: z.string().min(1).max(2000),
});
export const startRunSchema = z.object({
taskId: z.string().uuid(),
});
export const cancelRunSchema = z.object({
runId: z.string().uuid(),
});
export const runLogSchema = z.object({
runId: z.string().uuid(),
});
export const deleteEntitySchema = z.object({
id: z.string().uuid(),
companyId: z.string().uuid(),
});
export const sidebarBadgesSchema = z.object({
pendingApprovals: z.number(),
activeRuns: z.number(),
failedRuns: z.number(),
todoTasks: z.number(),
budgetWarnings: z.number(),
});
export type SidebarBadges = z.infer<typeof sidebarBadgesSchema>;
export const settingsSchema = z.object({
theme: z.enum(["system", "light", "dark"]).optional(),
updatesEnabled: z.boolean().optional(),
logRetentionDays: z.number().int().min(1).max(365).optional(),
});
export const commentInputSchema = z.object({
companyId: z.string().uuid(),
taskId: z.string().uuid(),
authorAgentId: optionalId,
authorName: z.string().min(1).max(80),
body: z.string().min(1).max(4000),
});
export const listCommentsSchema = z.object({
taskId: z.string().uuid(),
});
export const heartbeatSettingsSchema = z.object({
agentId: z.string().uuid(),
companyId: z.string().uuid(),
enabled: z.boolean(),
intervalSec: z.number().int().min(30).max(86400).default(120),
});
export const triggerHeartbeatSchema = z.object({
agentId: z.string().uuid(),
companyId: z.string().uuid(),
trigger: z.enum(["manual", "timer", "assignment", "goal_activated", "approval_resolved", "subtask_completed", "comment", "report_blocked", "report_failed", "recovery"]).default("manual"),
});
export type DesktopResult<T> =
| { ok: true; data: T }
| { ok: false; error: { code: string; message: string } };
export type DesktopApi = {
loadSnapshot: () => Promise<DesktopResult<ProfileSnapshot>>;
pickDirectory: () => Promise<DesktopResult<string | null>>;
openPath: (targetPath: string) => Promise<DesktopResult<boolean>>;
saveCompany: (input: z.infer<typeof companyInputSchema>) => Promise<DesktopResult<string>>;
setCurrentCompany: (companyId: string) => Promise<DesktopResult<boolean>>;
saveConnector: (input: z.infer<typeof connectorInputSchema>) => Promise<DesktopResult<boolean>>;
testConnector: (id: z.infer<typeof connectorInputSchema.shape.id>) => Promise<DesktopResult<boolean>>;
saveWorkspace: (input: z.infer<typeof workspaceInputSchema>) => Promise<DesktopResult<string>>;
saveAgent: (input: z.infer<typeof agentInputSchema>) => Promise<DesktopResult<string>>;
saveGoal: (input: z.infer<typeof goalInputSchema>) => Promise<DesktopResult<string>>;
saveProject: (input: z.infer<typeof projectInputSchema>) => Promise<DesktopResult<string>>;
saveTask: (input: z.infer<typeof taskInputSchema>) => Promise<DesktopResult<string>>;
requestApproval: (input: z.infer<typeof approvalInputSchema>) => Promise<DesktopResult<string>>;
decideApproval: (input: z.infer<typeof approvalDecisionSchema>) => Promise<DesktopResult<boolean>>;
saveSecret: (input: z.infer<typeof secretInputSchema>) => Promise<DesktopResult<string>>;
startTaskRun: (input: z.infer<typeof startRunSchema>) => Promise<DesktopResult<string>>;
cancelRun: (input: z.infer<typeof cancelRunSchema>) => Promise<DesktopResult<boolean>>;
getRunLog: (input: z.infer<typeof runLogSchema>) => Promise<DesktopResult<string>>;
backupProfile: () => Promise<DesktopResult<string | null>>;
restoreProfile: () => Promise<DesktopResult<boolean>>;
updateSettings: (input: z.infer<typeof settingsSchema>) => Promise<DesktopResult<boolean>>;
checkForUpdates: () => Promise<DesktopResult<boolean>>;
deleteCompany: (companyId: string) => Promise<DesktopResult<boolean>>;
deleteAgent: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
deleteTask: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
deleteGoal: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
deleteProject: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
deleteWorkspace: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
deleteApproval: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
deleteSecret: (input: z.infer<typeof deleteEntitySchema>) => Promise<DesktopResult<boolean>>;
getSidebarBadges: (companyId: string) => Promise<DesktopResult<SidebarBadges>>;
listConnectorModels: (connectorId: string) => Promise<DesktopResult<Array<{ id: string; label: string }>>>;
addComment: (input: z.infer<typeof commentInputSchema>) => Promise<DesktopResult<string>>;
listComments: (input: z.infer<typeof listCommentsSchema>) => Promise<DesktopResult<CommentRecord[]>>;
setHeartbeat: (input: z.infer<typeof heartbeatSettingsSchema>) => Promise<DesktopResult<boolean>>;
triggerHeartbeat: (input: z.infer<typeof triggerHeartbeatSchema>) => Promise<DesktopResult<string>>;
getApiPort: () => Promise<DesktopResult<number>>;
subscribe: (callback: (event: DesktopEvent) => void) => () => void;
};
+321
View File
@@ -0,0 +1,321 @@
export type SectionId =
| "overview"
| "connectors"
| "agents"
| "orgchart"
| "goals"
| "projects"
| "tasks"
| "approvals"
| "costs"
| "activity"
| "workspaces"
| "settings";
export type ConnectorId =
| "codex_local"
| "claude_local"
| "gemini_local"
| "opencode_local"
| "kimi_local";
export type ConnectorStatus =
| "not_installed"
| "detected"
| "auth_required"
| "ready"
| "degraded"
| "error";
export type WorkspaceState = "ready" | "busy" | "blocked" | "missing" | "error";
export type CompanyStatus = "active" | "paused" | "archived";
export type AgentStatus =
| "idle"
| "active"
| "running"
| "paused"
| "error"
| "pending_approval"
| "terminated";
export type GoalStatus = "planned" | "active" | "achieved" | "cancelled";
export type ProjectStatus = "backlog" | "planned" | "in_progress" | "completed" | "cancelled";
export type TaskStatus = "backlog" | "todo" | "in_progress" | "in_review" | "done" | "blocked" | "cancelled";
export type ApprovalState = "pending" | "approved" | "rejected" | "revision_requested";
export type RunStatus =
| "queued"
| "running"
| "succeeded"
| "failed"
| "cancelled"
| "timed_out"
| "interrupted";
export interface CapabilityMatrix {
sessionResume: boolean;
gracefulCancel: boolean;
modelDiscovery: boolean;
structuredTranscript: boolean;
costAttribution: boolean;
}
export interface CompanyRecord {
id: string;
name: string;
description: string;
status: CompanyStatus;
createdAt: string;
updatedAt: string;
}
export interface ConnectorRecord {
id: ConnectorId;
label: string;
description: string;
status: ConnectorStatus;
command: string;
version: string | null;
authState: "unknown" | "ok" | "required" | "error";
lastCheckedAt: string | null;
lastError: string | null;
model: string | null;
envBindingText: string;
notes: string;
configurationDoc: string;
capabilityMatrix: CapabilityMatrix;
}
export interface WorkspaceRecord {
id: string;
companyId: string;
name: string;
localPath: string;
repoUrl: string;
repoRef: string;
projectId: string | null;
state: WorkspaceState;
isPrimary: boolean;
createdAt: string;
updatedAt: string;
}
export interface AgentRecord {
id: string;
companyId: string;
name: string;
role: string;
title: string;
status: AgentStatus;
reportsTo: string | null;
connectorId: ConnectorId;
workspaceId: string | null;
model: string | null;
capabilities: string;
budgetMonthlyUsd: number;
spentMonthlyUsd: number;
metadataJson: string;
heartbeatEnabled: boolean;
heartbeatIntervalSec: number;
lastHeartbeatAt: string | null;
createdAt: string;
updatedAt: string;
}
export interface GoalRecord {
id: string;
companyId: string;
title: string;
description: string;
parentId: string | null;
ownerAgentId: string | null;
status: GoalStatus;
createdAt: string;
updatedAt: string;
}
export interface ProjectRecord {
id: string;
companyId: string;
goalId: string | null;
name: string;
description: string;
leadAgentId: string | null;
status: ProjectStatus;
targetDate: string | null;
createdAt: string;
updatedAt: string;
}
export interface TaskRecord {
id: string;
companyId: string;
projectId: string | null;
goalId: string | null;
parentId: string | null;
title: string;
description: string;
assigneeAgentId: string | null;
workspaceId: string | null;
status: TaskStatus;
priority: "critical" | "high" | "medium" | "low";
activeRunId: string | null;
sessionJson: string | null;
sessionDisplayId: string | null;
costUsd: number;
createdAt: string;
updatedAt: string;
}
export interface ApprovalRecord {
id: string;
companyId: string;
relatedTaskId: string | null;
relatedAgentId: string | null;
requestedByAgentId: string | null;
type: "hire_agent" | "approve_ceo_strategy" | "dangerous_command" | "secret_access";
payloadSummary: string;
impactSummary: string;
payloadJson: string | null;
decisionNote: string;
state: ApprovalState;
createdAt: string;
updatedAt: string;
}
export interface RunRecord {
id: string;
companyId: string;
taskId: string;
agentId: string;
workspaceId: string | null;
connectorId: ConnectorId;
status: RunStatus;
summary: string;
errorMessage: string | null;
exitCode: number | null;
signal: string | null;
model: string | null;
sessionDisplayId: string | null;
costUsd: number | null;
unattributedCost: boolean;
startedAt: string | null;
finishedAt: string | null;
logPath: string | null;
createdAt: string;
updatedAt: string;
}
export interface CostRecord {
id: string;
companyId: string;
runId: string;
taskId: string | null;
agentId: string | null;
connectorId: ConnectorId;
amountUsd: number | null;
unattributed: boolean;
createdAt: string;
}
export interface ActivityRecord {
id: string;
companyId: string;
actor: string;
action: string;
entityType: string;
entityId: string;
detail: string;
createdAt: string;
}
export interface SecretRecord {
id: string;
companyId: string;
name: string;
description: string;
backend: "safe_storage" | "vault";
updatedAt: string;
}
export interface ProfileSnapshot {
currentCompanyId: string | null;
profilePath: string;
updatesEnabled: boolean;
theme: "system" | "light" | "dark";
backend: {
secretBackend: string;
};
companies: CompanyRecord[];
connectors: ConnectorRecord[];
workspaces: WorkspaceRecord[];
agents: AgentRecord[];
goals: GoalRecord[];
projects: ProjectRecord[];
tasks: TaskRecord[];
approvals: ApprovalRecord[];
runs: RunRecord[];
costs: CostRecord[];
activity: ActivityRecord[];
secrets: SecretRecord[];
comments: CommentRecord[];
}
export interface LogChunkEvent {
type: "run-log";
runId: string;
stream: "stdout" | "stderr";
chunk: string;
}
export interface DomainChangedEvent {
type: "domain-changed";
}
export interface ShortcutEvent {
type: "shortcut";
action: "toggle-command-palette" | "toggle-console" | "refresh";
}
export interface RunStatusEvent {
type: "run-status";
runId: string;
status: RunStatus;
message: string;
}
export type HeartbeatTrigger = "manual" | "timer" | "assignment" | "goal_activated" | "approval_resolved" | "subtask_completed" | "comment" | "report_blocked" | "report_failed" | "recovery";
export interface CommentRecord {
id: string;
companyId: string;
taskId: string;
authorAgentId: string | null;
authorName: string;
body: string;
createdAt: string;
}
export interface OrgChartNode {
agent: AgentRecord;
children: OrgChartNode[];
}
export interface HeartbeatStatusEvent {
type: "heartbeat-status";
agentId: string;
enabled: boolean;
nextWakeAt: string | null;
}
export interface AgentMessageEvent {
type: "agent-message";
taskId: string;
comment: CommentRecord;
}
export type DesktopEvent =
| LogChunkEvent
| DomainChangedEvent
| ShortcutEvent
| RunStatusEvent
| HeartbeatStatusEvent
| AgentMessageEvent;