File size: 9,925 Bytes
103a492
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
"""List current builds through their native reader doors."""

from dataclasses import replace
from urllib.parse import urlencode

from fastapi import HTTPException

from core import external_tools, grid_events, table_store
from deps import Session, err
import intelligence_store as brain
import wiki_log


KINDS = tuple(sorted(wiki_log.KINDS))
MISSING_DESCRIPTION = "Description missing."


def _permitted(session, module):
    try:
        session.require(module)
        return True
    except HTTPException as exc:
        if exc.status_code != 403:
            raise
        return False


def _views(ctx):
    from routes_external import _assert_database_scope
    from routes_shares import _field_storage_keys

    for database in ctx.list_databases()["databases"]:
        if not database.get("permitted"):
            continue
        key = database["database"]
        _assert_database_scope(ctx.session, key)
        tops = table_store.make(_field_storage_keys(key)[0], st=ctx.session.runtime)
        event = grid_events.EventCtx(
            uname=ctx.session.uname, allowed_pids=frozenset(), fields=[],
            admin=ctx.session.admin, st=ctx.session.runtime, table=tops,
            scope_key={"customer_data": "customer", "product_data": "product"}.get(key, key))
        workspace = grid_events.table_workspace(event, allowed_pids=frozenset(), consume_corrections=False)
        for row in (workspace.get("views") or {}).values():
            yield "view", row["id"], key, row


def _workbooks(ctx):
    from routes_external import _assert_workbook_scope
    from routes_sheet import list_sheets

    if _permitted(ctx.session, "sheets"):
        for row in list_sheets(session=ctx.session)["workbooks"]:
            try:
                _assert_workbook_scope(ctx.session, row["id"])
            except HTTPException as exc:
                if exc.status_code not in (403, 404):
                    raise
                continue
            yield "workbook", row["id"], "", row


def _apps(ctx):
    import application_registry as applications
    from .apps import _read, list_apps

    for row in list_apps(ctx, {})["applications"]:
        try:
            _read(ctx, row["id"])
        except (applications.ApplicationError, PermissionError):
            continue
        except HTTPException as exc:
            if exc.status_code not in (403, 404):
                raise
            continue
        yield "app", row["id"], "", row


def _automations(ctx):
    import automation_engine
    from .automations import list_automations

    if _permitted(ctx.session, "automation"):
        allowed = list_automations(ctx, {})
        definitions = automation_engine.all_definitions(ctx.session.runtime) if allowed else {}
        for row in allowed:
            yield "automation", row["id"], "", definitions.get(row["id"], row)


def _schedules(ctx):
    from .schedules import list_schedules

    for row in list_schedules(ctx, {}):
        yield "schedule", row["id"], "", row


def _brain(ctx):
    if not _permitted(ctx.session, "intelligence"):
        return
    offset = 0
    while True:
        page = brain.list_files(ctx.session, offset=offset, limit=100)
        for row in page["files"]:
            path = row["path"]
            if wiki_log.reserved(path) or wiki_log.purpose_file(path):
                continue
            kind = "skill" if row["section"] in {"playbooks", "agent-prompts"} else "file"
            yield kind, path, "", row
        offset += len(page["files"])
        if offset >= page["total"]:
            return
        if not page["files"]:
            raise err(503, "tool_unavailable", "Brain files could not be listed. Try again.")


def _updated(row):
    for key in ("updated", "updatedAt", "updated_at"):
        if row.get(key):
            return row[key]
    return None


def _resolve(session, target, documents):
    if target["kind"] != "view" or _permitted(session, "intelligence"):
        return wiki_log.resolve_object(session, target, documents)
    # Wiki resolution requires Brain access. View inventory uses the same native source and share checks.
    from routes_shares import _field_storage_keys
    tops = table_store.make(_field_storage_keys(target["database"])[0], st=session.runtime)
    found = tops.find_view(target["id"], prefer_owner=session.uname)
    if not found:
        return None
    owner, view = found[:2]
    if owner != session.uname and not grid_events._shared_view_role(
            tops, target["id"], owner, session.uname, st=session.runtime):
        return None
    return {**target, "title": view.get("name") or target["id"], "owner": owner,
            "href": "#/data?" + urlencode({"database": target["database"], "view": target["id"]})}


def list_files(ctx, args):
    """List all readable builds in kind and title order, with filters and stable cursor pages."""
    from routes_external import (
        _PreviewRuntime, _decode_query_cursor, _encode_query_cursor, _json_digest,
        _tool_context, require_external_analyst,
    )

    if not isinstance(ctx, external_tools.ToolContext) or not isinstance(ctx.session, Session):
        raise err(403, "tool_context_required", "Use an authenticated AI connection.")
    require_external_analyst(ctx.session)
    if ctx.session.runtime.key != ctx.session.tenant:
        raise err(403, "tool_context_required", "Use this workspace's authenticated AI connection.")
    external_tools.validate_arguments(args, GROUP["actions"]["list"]["schema"])
    # Native readers may migrate old workspaces. Keep those writes in a private snapshot.
    class InventoryRuntime(_PreviewRuntime):
        def _read_strict(self, name):
            return self.get(name)

    session = replace(ctx.session, runtime=InventoryRuntime(ctx.session.runtime))
    ctx = _tool_context(session)
    if not session.runtime.available():
        raise err(503, "store_unavailable", "The workspace store is unavailable. Try again.")
    documents = (brain._files(session)
                 if _permitted(session, "intelligence") else {})
    wanted = args.get("kind")
    listers = {"view": _views, "workbook": _workbooks, "app": _apps,
               "automation": _automations, "schedule": _schedules, "file": _brain, "skill": _brain}
    selected = list(dict.fromkeys(listers[kind] for kind in KINDS if wanted in (None, kind)))
    rows = {}
    for lister in selected:
        for kind, identity, database, native in lister(ctx):
            if wanted is not None and wanted != kind:
                continue
            target = {"kind": kind, "id": identity, "database": database}
            obj = _resolve(session, target, documents)
            if obj is None:
                continue
            metadata = (wiki_log.build_metadata(session, obj, documents) if documents else {})
            about = metadata.get("about") if metadata.get("buildKind") == kind else None
            tags = sorted(about["tags"]) if about else []
            if args.get("tag") is not None and args["tag"] not in tags:
                continue
            rows[(kind, identity, database)] = {
                **target, "title": obj["title"], "owner": obj["owner"], "href": obj["href"],
                "description": about["description"] if about else MISSING_DESCRIPTION,
                "descriptionMissing": about is None, "tags": tags, "updated": _updated(native),
            }
    ordered = sorted(rows.values(), key=lambda row: (
        row["kind"], row["title"].casefold(), row["title"], row["id"], row["database"]))
    limit = args.get("limit", 100)
    query = _json_digest({"tool": "files.list", "kind": wanted, "tag": args.get("tag"), "limit": limit})
    snapshot = _json_digest(ordered)
    offset = (_decode_query_cursor(session, args["cursor"], query, snapshot)
              if args.get("cursor") is not None else 0)
    if offset > len(ordered):
        raise err(409, "query_cursor_stale", "The visible files changed. Start again without a cursor.")
    page = ordered[offset:offset + limit]
    end = offset + len(page)
    cursor = _encode_query_cursor(session, query, snapshot, end) if end < len(ordered) else None
    return {"files": page, "total": len(ordered), "page": {
        "limit": limit, "offset": offset, "returned": len(page),
        "has_more": cursor is not None, "next_cursor": cursor,
    }}


GROUP = {
    "name": "files", "title": "Files",
    "guide": "Use files.list to list current readable builds across Views, Sheet workbooks, Apps, "
             "Automations, Schedules, Brain files and Skills. Each row has kind, id, database, title, "
             "description, tags, owner, updated and href. Titles come from the current object. "
             "Builds without readable C5 metadata set descriptionMissing=true and use 'Description missing.' "
             "Updated is null when the native record has no update timestamp. "
             "Filter by kind or one canonical tag. Rows sort by kind, then title ignoring case, "
             "then exact title, id and database. Default limit is 100, maximum 500 per page. "
             "Follow page.next_cursor with the same filters and limit until it is null. "
             "There is no total inventory cap. A changed result set requires a restart without a cursor. "
             "This action reads metadata only and cannot grant access or change builds.",
    "actions": {"list": {
        "read": True, "destructive": False, "confirm": False, "handler": list_files,
        "schema": {"type": "object", "description": list_files.__doc__, "properties": {
            "kind": {"type": "string", "enum": list(KINDS)},
            "tag": {"type": "string", "enum": list(external_tools.BUILD_TAGS)},
            "limit": {"type": "integer", "minimum": 1, "maximum": 500},
            "cursor": {"type": "string", "minLength": 1, "maxLength": 768},
        }, "additionalProperties": False},
    }},
}